sig
  module Integer :
    sig
      module type Base =
        sig
          type t
          val zero : Bap.Std.Integer.Base.t
          val one : Bap.Std.Integer.Base.t
          val succ : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val pred : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val abs : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val neg : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val add :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val sub :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val mul :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val div :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val modulo :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val lnot : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val logand :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val logor :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val logxor :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val lshift :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val rshift :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
          val arshift :
            Bap.Std.Integer.Base.t ->
            Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
        end
      module type S =
        sig
          type t
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( + ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( - ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( * ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( / ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( mod ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( land ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( lor ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( lxor ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( lsl ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( lsr ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
          val ( asr ) :
            Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
        end
      module Make :
        functor (T : Base->
          sig
            type t = T.t
            val zero : t
            val one : t
            val succ : t -> t
            val pred : t -> t
            val abs : t -> t
            val neg : t -> t
            val add : t -> t -> t
            val sub : t -> t -> t
            val mul : t -> t -> t
            val div : t -> t -> t
            val modulo : t -> t -> t
            val lnot : t -> t
            val logand : t -> t -> t
            val logor : t -> t -> t
            val logxor : t -> t -> t
            val lshift : t -> t -> t
            val rshift : t -> t -> t
            val arshift : t -> t -> t
            val ( ~- ) : t -> t
            val ( + ) : t -> t -> t
            val ( - ) : t -> t -> t
            val ( * ) : t -> t -> t
            val ( / ) : t -> t -> t
            val ( mod ) : t -> t -> t
            val ( land ) : t -> t -> t
            val ( lor ) : t -> t -> t
            val ( lxor ) : t -> t -> t
            val ( lsl ) : t -> t -> t
            val ( lsr ) : t -> t -> t
            val ( asr ) : t -> t -> t
          end
    end
  module Legacy :
    sig
      module Monad :
        sig
          module type Basic = Core_kernel.Monad.Basic
          module type Basic2 = Core_kernel.Monad.Basic2
          module type Infix = Core_kernel.Monad.Infix
          module type Infix2 = Core_kernel.Monad.Infix2
          module type S = Core_kernel.Monad.S
          module type S2 = Core_kernel.Monad.S2
          module Make :
            functor (M : Basic->
              sig
                val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                module Monad_infix :
                  sig
                    val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                    val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                  end
                val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                val return : '-> 'M.t
                val map : 'M.t -> f:('-> 'b) -> 'M.t
                val join : 'M.t M.t -> 'M.t
                val ignore_m : 'M.t -> unit M.t
                val all : 'M.t list -> 'a list M.t
                val all_unit : unit M.t list -> unit M.t
                val all_ignore : unit M.t list -> unit M.t
                module Let_syntax :
                  sig
                    val return : '-> 'M.t
                    val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                    val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                    module Let_syntax :
                      sig
                        val return : '-> 'M.t
                        val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                        val map : 'M.t -> f:('-> 'b) -> 'M.t
                        val both : 'M.t -> 'M.t -> ('a * 'b) M.t
                        module Open_on_rhs : sig  end
                      end
                  end
              end
          module Make2 :
            functor (M : Basic2->
              sig
                val ( >>= ) :
                  ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) M.t
                    val ( >>= ) :
                      ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) M.t
                        val bind :
                          ('a, 'e) M.t ->
                          f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val map :
                          ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                        val both :
                          ('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                  end
                val bind :
                  ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val return : '-> ('a, 'b) M.t
                val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
                val ignore_m : ('a, 'e) M.t -> (unit, 'e) M.t
                val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
                val all_unit : (unit, 'e) M.t list -> (unit, 'e) M.t
                val all_ignore : (unit, 'e) M.t list -> (unit, 'e) M.t
              end
          module State :
            sig
              module type S =
                sig
                  type ('a, 's) t
                  type 'a result
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (unit, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_unit : (unit, 'e) t list -> (unit, 'e) t
                  val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                  val put : '-> (unit, 's) Bap.Std.Legacy.Monad.State.S.t
                  val get : unit -> ('s, 's) Bap.Std.Legacy.Monad.State.S.t
                  val gets :
                    ('-> 'r) -> ('r, 's) Bap.Std.Legacy.Monad.State.S.t
                  val update :
                    ('-> 's) -> (unit, 's) Bap.Std.Legacy.Monad.State.S.t
                  val modify :
                    ('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
                    ('-> 's) -> ('a, 's) Bap.Std.Legacy.Monad.State.S.t
                  val run :
                    ('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
                    '-> ('a * 's) Bap.Std.Legacy.Monad.State.S.result
                  val eval :
                    ('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
                    '-> 'Bap.Std.Legacy.Monad.State.S.result
                  val exec :
                    ('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
                    '-> 'Bap.Std.Legacy.Monad.State.S.result
                end
              type ('a, 'e) t = ('a, 'e) Monads.Std.Monad.State.t
              type 'a result = 'a
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (unit, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit : (unit, 'e) t list -> (unit, 'e) t
              val all_ignore : (unit, 'e) t list -> (unit, 'e) t
              val put : '-> (unit, 's) t
              val get : unit -> ('s, 's) t
              val gets : ('-> 'r) -> ('r, 's) t
              val update : ('-> 's) -> (unit, 's) t
              val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
              val run : ('a, 's) t -> '-> 'a * 's
              val eval : ('a, 's) t -> '-> 'a
              val exec : ('a, 's) t -> '-> 's
            end
          module T :
            sig
              module Option :
                sig
                  module Make :
                    functor (M : S->
                      sig
                        type 'a t = 'a option M.t
                        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                        module Monad_infix :
                          sig
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                          end
                        val bind : 'a t -> f:('-> 'b t) -> 'b t
                        val return : '-> 'a t
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val join : 'a t t -> 'a t
                        val ignore_m : 'a t -> unit t
                        val all : 'a t list -> 'a list t
                        val all_unit : unit t list -> unit t
                        val all_ignore : unit t list -> unit t
                        module Let_syntax :
                          sig
                            val return : '-> 'a t
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                            module Let_syntax :
                              sig
                                val return : '-> 'a t
                                val bind : 'a t -> f:('-> 'b t) -> 'b t
                                val map : 'a t -> f:('-> 'b) -> 'b t
                                val both : 'a t -> 'b t -> ('a * 'b) t
                                module Open_on_rhs : sig  end
                              end
                          end
                      end
                  module Make2 :
                    functor (M : S2->
                      sig
                        type ('a, 'b) t = ('a option, 'b) M.t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val bind :
                                  ('a, 'e) t ->
                                  f:('-> ('b, 'e) t) -> ('b, 'e) t
                                val map :
                                  ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                                val both :
                                  ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          end
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val return : '-> ('a, 'b) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                        val ignore_m : ('a, 'e) t -> (unit, 'e) t
                        val all : ('a, 'e) t list -> ('a list, 'e) t
                        val all_unit : (unit, 'e) t list -> (unit, 'e) t
                        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                      end
                end
              module Or_error :
                sig
                  module Make :
                    functor (M : S->
                      sig
                        type 'a t = 'Core_kernel.Or_error.t M.t
                        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                        module Monad_infix :
                          sig
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                          end
                        val bind : 'a t -> f:('-> 'b t) -> 'b t
                        val return : '-> 'a t
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val join : 'a t t -> 'a t
                        val ignore_m : 'a t -> unit t
                        val all : 'a t list -> 'a list t
                        val all_unit : unit t list -> unit t
                        val all_ignore : unit t list -> unit t
                        module Let_syntax :
                          sig
                            val return : '-> 'a t
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                            module Let_syntax :
                              sig
                                val return : '-> 'a t
                                val bind : 'a t -> f:('-> 'b t) -> 'b t
                                val map : 'a t -> f:('-> 'b) -> 'b t
                                val both : 'a t -> 'b t -> ('a * 'b) t
                                module Open_on_rhs : sig  end
                              end
                          end
                      end
                  module Make2 :
                    functor (M : S2->
                      sig
                        type ('a, 'b) t = ('Core_kernel.Or_error.t, 'b) M.t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val bind :
                                  ('a, 'e) t ->
                                  f:('-> ('b, 'e) t) -> ('b, 'e) t
                                val map :
                                  ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                                val both :
                                  ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          end
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val return : '-> ('a, 'b) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                        val ignore_m : ('a, 'e) t -> (unit, 'e) t
                        val all : ('a, 'e) t list -> ('a list, 'e) t
                        val all_unit : (unit, 'e) t list -> (unit, 'e) t
                        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                      end
                end
              module Result :
                sig
                  module Make :
                    functor (M : S->
                      sig
                        type ('a, 'e) t = ('a, 'e) Core_kernel.Result.t M.t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val bind :
                                  ('a, 'e) t ->
                                  f:('-> ('b, 'e) t) -> ('b, 'e) t
                                val map :
                                  ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                                val both :
                                  ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          end
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val return : '-> ('a, 'b) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                        val ignore_m : ('a, 'e) t -> (unit, 'e) t
                        val all : ('a, 'e) t list -> ('a list, 'e) t
                        val all_unit : (unit, 'e) t list -> (unit, 'e) t
                        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                      end
                end
              module State :
                sig
                  module Make :
                    functor (M : S->
                      sig
                        type ('a, 's) t
                        type 'a result = 'M.t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val bind :
                                  ('a, 'e) t ->
                                  f:('-> ('b, 'e) t) -> ('b, 'e) t
                                val map :
                                  ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                                val both :
                                  ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          end
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val return : '-> ('a, 'b) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                        val ignore_m : ('a, 'e) t -> (unit, 'e) t
                        val all : ('a, 'e) t list -> ('a list, 'e) t
                        val all_unit : (unit, 'e) t list -> (unit, 'e) t
                        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                        val put : '-> (unit, 's) t
                        val get : unit -> ('s, 's) t
                        val gets : ('-> 'r) -> ('r, 's) t
                        val update : ('-> 's) -> (unit, 's) t
                        val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
                        val run : ('a, 's) t -> '-> ('a * 's) result
                        val eval : ('a, 's) t -> '-> 'a result
                        val exec : ('a, 's) t -> '-> 's result
                      end
                end
            end
        end
    end
  module Seq :
    sig
      type 'a t = 'Core_kernel.Sequence.t
      val bin_t :
        'Core_kernel.Bin_prot.Type_class.t ->
        'a t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t :
        'Core_kernel.Bin_prot.Read.reader ->
        'a t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ :
        'Core_kernel.Bin_prot.Read.reader ->
        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t :
        'Core_kernel.Bin_prot.Type_class.reader ->
        'a t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t :
        'Core_kernel.Bin_prot.Size.sizer ->
        'a t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t :
        'Core_kernel.Bin_prot.Write.writer ->
        'a t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t :
        'Core_kernel.Bin_prot.Type_class.writer ->
        'a t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t :
        Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
      val t_of_sexp :
        (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t
      module Merge_with_duplicates_element :
        sig
          type ('a, 'b) t =
            ('a, 'b) Base.Sequence.Merge_with_duplicates_element.t =
              Left of 'a
            | Right of 'b
            | Both of 'a * 'b
          val bin_t :
            'Bin_prot.Type_class.t ->
            'Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t
          val bin_read_t :
            'Bin_prot.Read.reader ->
            'Bin_prot.Read.reader -> ('a, 'b) t Bin_prot.Read.reader
          val __bin_read_t__ :
            'Bin_prot.Read.reader ->
            'Bin_prot.Read.reader ->
            (int -> ('a, 'b) t) Bin_prot.Read.reader
          val bin_reader_t :
            'Bin_prot.Type_class.reader ->
            'Bin_prot.Type_class.reader ->
            ('a, 'b) t Bin_prot.Type_class.reader
          val bin_size_t :
            'Bin_prot.Size.sizer ->
            'Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
          val bin_write_t :
            'Bin_prot.Write.writer ->
            'Bin_prot.Write.writer -> ('a, 'b) t Bin_prot.Write.writer
          val bin_writer_t :
            'Bin_prot.Type_class.writer ->
            'Bin_prot.Type_class.writer ->
            ('a, 'b) t Bin_prot.Type_class.writer
          val bin_shape_t :
            Bin_prot.Shape.t -> Bin_prot.Shape.t -> Bin_prot.Shape.t
          val compare :
            ('-> '-> int) ->
            ('-> '-> int) -> ('a, 'b) t -> ('a, 'b) t -> int
          val hash_fold_t :
            (Base__.Ppx_hash_lib.Std.Hash.state ->
             '-> Base__.Ppx_hash_lib.Std.Hash.state) ->
            (Base__.Ppx_hash_lib.Std.Hash.state ->
             '-> Base__.Ppx_hash_lib.Std.Hash.state) ->
            Base__.Ppx_hash_lib.Std.Hash.state ->
            ('a, 'b) t -> Base__.Ppx_hash_lib.Std.Hash.state
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'b) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> ('a, 'b) t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            ('a, 'b) t -> Base__.Ppx_sexp_conv_lib.Sexp.t
        end
      val sexp_of_t :
        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
      type 'a sequence = 'a t
      val mem : 'a sequence -> '-> equal:('-> '-> bool) -> bool
      val length : 'a sequence -> int
      val iter : 'a sequence -> f:('-> unit) -> unit
      val fold :
        'a sequence -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
      val fold_result :
        'a sequence ->
        init:'accum ->
        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
        ('accum, 'e) Base__.Result.t
      val fold_until :
        'a sequence ->
        init:'accum ->
        f:('accum ->
           '-> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
        finish:('accum -> 'final) -> 'final
      val exists : 'a sequence -> f:('-> bool) -> bool
      val for_all : 'a sequence -> f:('-> bool) -> bool
      val count : 'a sequence -> f:('-> bool) -> int
      val sum :
        (module Base__.Commutative_group.S with type t = 'sum) ->
        'a sequence -> f:('-> 'sum) -> 'sum
      val find : 'a sequence -> f:('-> bool) -> 'a option
      val find_map : 'a sequence -> f:('-> 'b option) -> 'b option
      val to_list : 'a sequence -> 'a list
      val to_array : 'a sequence -> 'a array
      val min_elt : 'a sequence -> compare:('-> '-> int) -> 'a option
      val max_elt : 'a sequence -> compare:('-> '-> int) -> 'a option
      val foldi : ('a sequence, 'a, 'b) Base__.Indexed_container_intf.foldi
      val iteri : ('a sequence, 'a) Base__.Indexed_container_intf.iteri
      val existsi : 'a sequence -> f:(int -> '-> bool) -> bool
      val counti : 'a sequence -> f:(int -> '-> bool) -> int
      val findi : 'a sequence -> f:(int -> '-> bool) -> (int * 'a) option
      val find_mapi : 'a sequence -> f:(int -> '-> 'b option) -> 'b option
      val ( >>= ) : 'a sequence -> ('-> 'b sequence) -> 'b sequence
      val ( >>| ) : 'a sequence -> ('-> 'b) -> 'b sequence
      module Monad_infix :
        sig
          val ( >>= ) :
            'Base__Sequence.t ->
            ('-> 'Base__Sequence.t) -> 'Base__Sequence.t
          val ( >>| ) :
            'Base__Sequence.t -> ('-> 'b) -> 'Base__Sequence.t
        end
      val bind : 'a sequence -> f:('-> 'b sequence) -> 'b sequence
      val return : '-> 'a sequence
      val map : 'a sequence -> f:('-> 'b) -> 'b sequence
      val join : 'a sequence sequence -> 'a sequence
      val ignore_m : 'a sequence -> unit sequence
      val all : 'a sequence list -> 'a list sequence
      val all_unit : unit sequence list -> unit sequence
      val all_ignore : unit sequence list -> unit sequence
      module Let_syntax :
        sig
          val return : '-> 'Base__Sequence.t
          val ( >>= ) :
            'Base__Sequence.t ->
            ('-> 'Base__Sequence.t) -> 'Base__Sequence.t
          val ( >>| ) :
            'Base__Sequence.t -> ('-> 'b) -> 'Base__Sequence.t
          module Let_syntax :
            sig
              val return : '-> 'Base__Sequence.t
              val bind :
                'Base__Sequence.t ->
                f:('-> 'Base__Sequence.t) -> 'Base__Sequence.t
              val map :
                'Base__Sequence.t -> f:('-> 'b) -> 'Base__Sequence.t
              val both :
                'Base__Sequence.t ->
                'Base__Sequence.t -> ('a * 'b) Base__Sequence.t
              module Open_on_rhs : sig  end
            end
        end
      val empty : 'a sequence
      val next : 'a sequence -> ('a * 'a sequence) option
      module Step :
        sig
          type ('a, 's) t =
            ('a, 's) Base__Sequence.Step.t =
              Done
            | Skip of 's
            | Yield of 'a * 's
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            ('a, 's) t -> Base__.Ppx_sexp_conv_lib.Sexp.t
        end
      val unfold_step : init:'-> f:('-> ('a, 's) Step.t) -> 'a sequence
      val unfold : init:'-> f:('-> ('a * 's) option) -> 'a sequence
      val unfold_with :
        'a sequence ->
        init:'-> f:('-> '-> ('b, 's) Step.t) -> 'b sequence
      val unfold_with_and_finish :
        'a sequence ->
        init:'s_a ->
        running_step:('s_a -> '-> ('b, 's_a) Step.t) ->
        inner_finished:('s_a -> 's_b) ->
        finishing_step:('s_b -> ('b, 's_b) Step.t) -> 'b sequence
      val nth : 'a sequence -> int -> 'a option
      val nth_exn : 'a sequence -> int -> 'a
      val folding_map :
        'a sequence -> init:'-> f:('-> '-> 'b * 'c) -> 'c sequence
      val folding_mapi :
        'a sequence ->
        init:'-> f:(int -> '-> '-> 'b * 'c) -> 'c sequence
      val mapi : 'a sequence -> f:(int -> '-> 'b) -> 'b sequence
      val filteri : 'a sequence -> f:(int -> '-> bool) -> 'a sequence
      val merge :
        'a sequence -> 'a sequence -> cmp:('-> '-> int) -> 'a sequence
      val merge_with_duplicates :
        'a sequence ->
        'b sequence ->
        cmp:('-> '-> int) ->
        ('a, 'b) Merge_with_duplicates_element.t sequence
      val hd : 'a sequence -> 'a option
      val hd_exn : 'a sequence -> 'a
      val tl : 'a sequence -> 'a sequence option
      val tl_eagerly_exn : 'a sequence -> 'a sequence
      val find_exn : 'a sequence -> f:('-> bool) -> 'a
      val for_alli : 'a sequence -> f:(int -> '-> bool) -> bool
      val append : 'a sequence -> 'a sequence -> 'a sequence
      val concat : 'a sequence sequence -> 'a sequence
      val concat_map : 'a sequence -> f:('-> 'b sequence) -> 'b sequence
      val concat_mapi :
        'a sequence -> f:(int -> '-> 'b sequence) -> 'b sequence
      val interleave : 'a sequence sequence -> 'a sequence
      val round_robin : 'a sequence list -> 'a sequence
      val zip : 'a sequence -> 'b sequence -> ('a * 'b) sequence
      val zip_full :
        'a sequence ->
        'b sequence ->
        [ `Both of 'a * '| `Left of '| `Right of 'b ] sequence
      val reduce_exn : 'a sequence -> f:('-> '-> 'a) -> 'a
      val reduce : 'a sequence -> f:('-> '-> 'a) -> 'a option
      val group : 'a sequence -> break:('-> '-> bool) -> 'a list sequence
      val find_consecutive_duplicate :
        'a sequence -> equal:('-> '-> bool) -> ('a * 'a) option
      val remove_consecutive_duplicates :
        'a sequence -> equal:('-> '-> bool) -> 'a sequence
      val range :
        ?stride:int ->
        ?start:[ `exclusive | `inclusive ] ->
        ?stop:[ `exclusive | `inclusive ] -> int -> int -> int sequence
      val init : int -> f:(int -> 'a) -> 'a sequence
      val filter_map : 'a sequence -> f:('-> 'b option) -> 'b sequence
      val filter_mapi :
        'a sequence -> f:(int -> '-> 'b option) -> 'b sequence
      val filter_opt : 'a option sequence -> 'a sequence
      val sub : 'a sequence -> pos:int -> len:int -> 'a sequence
      val take : 'a sequence -> int -> 'a sequence
      val drop : 'a sequence -> int -> 'a sequence
      val drop_eagerly : 'a sequence -> int -> 'a sequence
      val take_while : 'a sequence -> f:('-> bool) -> 'a sequence
      val drop_while : 'a sequence -> f:('-> bool) -> 'a sequence
      val drop_while_option :
        'a sequence -> f:('-> bool) -> ('a * 'a sequence) option
      val split_n : 'a sequence -> int -> 'a list * 'a sequence
      val split_n_eagerly : 'a sequence -> int -> 'a sequence * 'a sequence
      val chunks_exn : 'a sequence -> int -> 'a list sequence
      val shift_right : 'a sequence -> '-> 'a sequence
      val shift_right_with_list : 'a sequence -> 'a list -> 'a sequence
      val shift_left : 'a sequence -> int -> 'a sequence
      module Infix :
        sig
          val ( @ ) :
            'Base__Sequence.t -> 'Base__Sequence.t -> 'Base__Sequence.t
        end
      val cartesian_product :
        'a sequence -> 'b sequence -> ('a * 'b) sequence
      val interleaved_cartesian_product :
        'a sequence -> 'b sequence -> ('a * 'b) sequence
      val intersperse : 'a sequence -> sep:'-> 'a sequence
      val cycle_list_exn : 'a list -> 'a sequence
      val repeat : '-> 'a sequence
      val singleton : '-> 'a sequence
      val delayed_fold :
        'a sequence ->
        init:'->
        f:('-> '-> k:('-> 'r) -> 'r) -> finish:('-> 'r) -> 'r
      val fold_m :
        bind:('acc_m -> f:('acc -> 'acc_m) -> 'acc_m) ->
        return:('acc -> 'acc_m) ->
        'elt sequence -> init:'acc -> f:('acc -> 'elt -> 'acc_m) -> 'acc_m
      val iter_m :
        bind:('unit_m -> f:(unit -> 'unit_m) -> 'unit_m) ->
        return:(unit -> 'unit_m) ->
        'elt sequence -> f:('elt -> 'unit_m) -> 'unit_m
      val to_list_rev : 'a sequence -> 'a list
      val of_list : 'a list -> 'a sequence
      val of_lazy : 'a sequence Base__.Lazy.t -> 'a sequence
      val memoize : 'a sequence -> 'a sequence
      val force_eagerly : 'a sequence -> 'a sequence
      val bounded_length :
        'a sequence -> at_most:int -> [ `Greater | `Is of int ]
      val length_is_bounded_by : ?min:int -> ?max:int -> 'a sequence -> bool
      module Generator :
        sig
          type ('a, 'e) t = ('a, 'e) Base__Sequence.Generator.t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_unit : (unit, 'e) t list -> (unit, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          val yield : 'elt -> (unit, 'elt) t
          val of_sequence : 'elt Base__Sequence.sequence -> (unit, 'elt) t
          val run : (unit, 'elt) t -> 'elt Base__Sequence.sequence
        end
      module Expert :
        sig
          val next_step :
            'Base__Sequence.t -> ('a, 'Base__Sequence.t) Step.t
          val delayed_fold_step :
            'Base__Sequence.t ->
            init:'->
            f:('-> 'a option -> k:('-> 'r) -> 'r) ->
            finish:('-> 'r) -> 'r
        end
      val merge_all :
        'a sequence list -> compare:('-> '-> int) -> 'a sequence
      val filter : 'a sequence -> f:('-> bool) -> 'a sequence
      val compare : ('-> '-> int) -> 'a sequence -> 'b sequence -> int
      val of_array : 'a array -> 'a sequence
      val cons : '-> 'a sequence -> 'a sequence
      val is_empty : 'a sequence -> bool
      val pp : 'Regular.Std.printer -> 'a sequence Regular.Std.printer
    end
  type 'a seq = 'Bap.Std.Seq.t
  val bin_seq :
    'Core_kernel.Bin_prot.Type_class.t ->
    'a seq Core_kernel.Bin_prot.Type_class.t
  val bin_read_seq :
    'Core_kernel.Bin_prot.Read.reader ->
    'a seq Core_kernel.Bin_prot.Read.reader
  val __bin_read_seq__ :
    'Core_kernel.Bin_prot.Read.reader ->
    (int -> 'a seq) Core_kernel.Bin_prot.Read.reader
  val bin_reader_seq :
    'Core_kernel.Bin_prot.Type_class.reader ->
    'a seq Core_kernel.Bin_prot.Type_class.reader
  val bin_size_seq :
    'Core_kernel.Bin_prot.Size.sizer ->
    'a seq Core_kernel.Bin_prot.Size.sizer
  val bin_write_seq :
    'Core_kernel.Bin_prot.Write.writer ->
    'a seq Core_kernel.Bin_prot.Write.writer
  val bin_writer_seq :
    'Core_kernel.Bin_prot.Type_class.writer ->
    'a seq Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_seq :
    Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
  val compare_seq : ('-> '-> int) -> 'a seq -> 'a seq -> int
  val seq_of_sexp :
    (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a seq
  val sexp_of_seq :
    ('-> Ppx_sexp_conv_lib.Sexp.t) -> 'a seq -> Ppx_sexp_conv_lib.Sexp.t
  module Trie :
    sig
      module type Key =
        sig
          type t
          type token
          val bin_token : token Core_kernel.Bin_prot.Type_class.t
          val bin_read_token : token Core_kernel.Bin_prot.Read.reader
          val __bin_read_token__ :
            (int -> token) Core_kernel.Bin_prot.Read.reader
          val bin_reader_token : token Core_kernel.Bin_prot.Type_class.reader
          val bin_size_token : token Core_kernel.Bin_prot.Size.sizer
          val bin_write_token : token Core_kernel.Bin_prot.Write.writer
          val bin_writer_token : token Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_token : Core_kernel.Bin_prot.Shape.t
          val compare_token : token -> token -> int
          val token_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> token
          val sexp_of_token : token -> Ppx_sexp_conv_lib.Sexp.t
          val length : Bap.Std.Trie.Key.t -> int
          val nth_token : Bap.Std.Trie.Key.t -> int -> Bap.Std.Trie.Key.token
          val token_hash : Bap.Std.Trie.Key.token -> int
        end
      module type S =
        sig
          type 'a t
          val bin_t :
            'Core_kernel.Bin_prot.Type_class.t ->
            'a t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t :
            'Core_kernel.Bin_prot.Read.reader ->
            'a t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ :
            'Core_kernel.Bin_prot.Read.reader ->
            (int -> 'a t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t :
            'Core_kernel.Bin_prot.Type_class.reader ->
            'a t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t :
            'Core_kernel.Bin_prot.Size.sizer ->
            'a t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t :
            'Core_kernel.Bin_prot.Write.writer ->
            'a t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t :
            'Core_kernel.Bin_prot.Type_class.writer ->
            'a t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t :
            Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          type key
          val create : unit -> 'Bap.Std.Trie.S.t
          val add :
            'Bap.Std.Trie.S.t -> key:Bap.Std.Trie.S.key -> data:'-> unit
          val change :
            'Bap.Std.Trie.S.t ->
            Bap.Std.Trie.S.key -> ('a option -> 'a option) -> unit
          val find : 'Bap.Std.Trie.S.t -> Bap.Std.Trie.S.key -> 'a option
          val walk :
            'Bap.Std.Trie.S.t ->
            Bap.Std.Trie.S.key -> init:'-> f:('-> 'a option -> 'b) -> 'b
          val remove : 'Bap.Std.Trie.S.t -> Bap.Std.Trie.S.key -> unit
          val longest_match :
            'Bap.Std.Trie.S.t -> Bap.Std.Trie.S.key -> (int * 'a) option
          val length : 'Bap.Std.Trie.S.t -> int
          val pp :
            'Regular.Std.printer -> 'Bap.Std.Trie.S.t Regular.Std.printer
        end
      module Make :
        functor (Key : Key->
          sig
            type 'a t
            val bin_t :
              'Core_kernel.Bin_prot.Type_class.t ->
              'a t Core_kernel.Bin_prot.Type_class.t
            val bin_read_t :
              'Core_kernel.Bin_prot.Read.reader ->
              'a t Core_kernel.Bin_prot.Read.reader
            val __bin_read_t__ :
              'Core_kernel.Bin_prot.Read.reader ->
              (int -> 'a t) Core_kernel.Bin_prot.Read.reader
            val bin_reader_t :
              'Core_kernel.Bin_prot.Type_class.reader ->
              'a t Core_kernel.Bin_prot.Type_class.reader
            val bin_size_t :
              'Core_kernel.Bin_prot.Size.sizer ->
              'a t Core_kernel.Bin_prot.Size.sizer
            val bin_write_t :
              'Core_kernel.Bin_prot.Write.writer ->
              'a t Core_kernel.Bin_prot.Write.writer
            val bin_writer_t :
              'Core_kernel.Bin_prot.Type_class.writer ->
              'a t Core_kernel.Bin_prot.Type_class.writer
            val bin_shape_t :
              Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
            val t_of_sexp :
              (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
              Ppx_sexp_conv_lib.Sexp.t -> 'a t
            val sexp_of_t :
              ('-> Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Ppx_sexp_conv_lib.Sexp.t
            type key = Key.t
            val create : unit -> 'a t
            val add : 'a t -> key:key -> data:'-> unit
            val change : 'a t -> key -> ('a option -> 'a option) -> unit
            val find : 'a t -> key -> 'a option
            val walk :
              'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
            val remove : 'a t -> key -> unit
            val longest_match : 'a t -> key -> (int * 'a) option
            val length : 'a t -> int
            val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
          end
      module type Token =
        sig
          type t
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val compare : t -> t -> int
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          val hash : Bap.Std.Trie.Token.t -> int
        end
      module Array :
        sig
          module Prefix :
            functor (Tok : Token->
              sig
                type 'a t
                val bin_t :
                  'Core_kernel.Bin_prot.Type_class.t ->
                  'a t Core_kernel.Bin_prot.Type_class.t
                val bin_read_t :
                  'Core_kernel.Bin_prot.Read.reader ->
                  'a t Core_kernel.Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Core_kernel.Bin_prot.Read.reader ->
                  (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                val bin_reader_t :
                  'Core_kernel.Bin_prot.Type_class.reader ->
                  'a t Core_kernel.Bin_prot.Type_class.reader
                val bin_size_t :
                  'Core_kernel.Bin_prot.Size.sizer ->
                  'a t Core_kernel.Bin_prot.Size.sizer
                val bin_write_t :
                  'Core_kernel.Bin_prot.Write.writer ->
                  'a t Core_kernel.Bin_prot.Write.writer
                val bin_writer_t :
                  'Core_kernel.Bin_prot.Type_class.writer ->
                  'a t Core_kernel.Bin_prot.Type_class.writer
                val bin_shape_t :
                  Core_kernel.Bin_prot.Shape.t ->
                  Core_kernel.Bin_prot.Shape.t
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                type key = Tok.t array
                val create : unit -> 'a t
                val add : 'a t -> key:key -> data:'-> unit
                val change : 'a t -> key -> ('a option -> 'a option) -> unit
                val find : 'a t -> key -> 'a option
                val walk :
                  'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                val remove : 'a t -> key -> unit
                val longest_match : 'a t -> key -> (int * 'a) option
                val length : 'a t -> int
                val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
              end
          module Suffix :
            functor (Tok : Token->
              sig
                type 'a t
                val bin_t :
                  'Core_kernel.Bin_prot.Type_class.t ->
                  'a t Core_kernel.Bin_prot.Type_class.t
                val bin_read_t :
                  'Core_kernel.Bin_prot.Read.reader ->
                  'a t Core_kernel.Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Core_kernel.Bin_prot.Read.reader ->
                  (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                val bin_reader_t :
                  'Core_kernel.Bin_prot.Type_class.reader ->
                  'a t Core_kernel.Bin_prot.Type_class.reader
                val bin_size_t :
                  'Core_kernel.Bin_prot.Size.sizer ->
                  'a t Core_kernel.Bin_prot.Size.sizer
                val bin_write_t :
                  'Core_kernel.Bin_prot.Write.writer ->
                  'a t Core_kernel.Bin_prot.Write.writer
                val bin_writer_t :
                  'Core_kernel.Bin_prot.Type_class.writer ->
                  'a t Core_kernel.Bin_prot.Type_class.writer
                val bin_shape_t :
                  Core_kernel.Bin_prot.Shape.t ->
                  Core_kernel.Bin_prot.Shape.t
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                type key = Tok.t array
                val create : unit -> 'a t
                val add : 'a t -> key:key -> data:'-> unit
                val change : 'a t -> key -> ('a option -> 'a option) -> unit
                val find : 'a t -> key -> 'a option
                val walk :
                  'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                val remove : 'a t -> key -> unit
                val longest_match : 'a t -> key -> (int * 'a) option
                val length : 'a t -> int
                val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
              end
        end
      module String :
        sig
          module Prefix :
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              type key = string
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          module Suffix :
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              type key = Prefix.key
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
        end
    end
  module Interval_tree :
    sig
      module type Interval =
        sig
          type t
          val compare : t -> t -> int
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type point
          val compare_point : point -> point -> int
          val sexp_of_point : point -> Ppx_sexp_conv_lib.Sexp.t
          val lower :
            Bap.Std.Interval_tree.Interval.t ->
            Bap.Std.Interval_tree.Interval.point
          val upper :
            Bap.Std.Interval_tree.Interval.t ->
            Bap.Std.Interval_tree.Interval.point
        end
      module type S =
        sig
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          type key
          type point
          val empty : 'Bap.Std.Interval_tree.S.t
          val singleton :
            Bap.Std.Interval_tree.S.key -> '-> 'Bap.Std.Interval_tree.S.t
          val least :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.point option
          val greatest :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.point option
          val min_binding :
            'Bap.Std.Interval_tree.S.t ->
            (Bap.Std.Interval_tree.S.key * 'a) option
          val max_binding :
            'Bap.Std.Interval_tree.S.t ->
            (Bap.Std.Interval_tree.S.key * 'a) option
          val add :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.key -> '-> 'Bap.Std.Interval_tree.S.t
          val dominators :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.key ->
            (Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Sequence.t
          val intersections :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.key ->
            (Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Sequence.t
          val intersects :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.key -> bool
          val dominates :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.key -> bool
          val contains :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.point -> bool
          val lookup :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.point ->
            (Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Sequence.t
          val map :
            'Bap.Std.Interval_tree.S.t ->
            f:('-> 'b) -> 'Bap.Std.Interval_tree.S.t
          val mapi :
            'Bap.Std.Interval_tree.S.t ->
            f:(Bap.Std.Interval_tree.S.key -> '-> 'b) ->
            'Bap.Std.Interval_tree.S.t
          val filter :
            'Bap.Std.Interval_tree.S.t ->
            f:('-> bool) -> 'Bap.Std.Interval_tree.S.t
          val filter_map :
            'Bap.Std.Interval_tree.S.t ->
            f:('-> 'b option) -> 'Bap.Std.Interval_tree.S.t
          val filter_mapi :
            'Bap.Std.Interval_tree.S.t ->
            f:(Bap.Std.Interval_tree.S.key -> '-> 'b option) ->
            'Bap.Std.Interval_tree.S.t
          val remove :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.key -> 'Bap.Std.Interval_tree.S.t
          val remove_intersections :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.key -> 'Bap.Std.Interval_tree.S.t
          val remove_dominators :
            'Bap.Std.Interval_tree.S.t ->
            Bap.Std.Interval_tree.S.key -> 'Bap.Std.Interval_tree.S.t
          val to_sequence :
            'Bap.Std.Interval_tree.S.t ->
            (Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Sequence.t
          val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
        end
      module Make :
        functor (Interval : Interval->
          sig
            type 'a t
            val sexp_of_t :
              ('-> Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Ppx_sexp_conv_lib.Sexp.t
            val empty : 'a t
            val singleton : Interval.t -> '-> 'a t
            val least : 'a t -> Interval.point option
            val greatest : 'a t -> Interval.point option
            val min_binding : 'a t -> (Interval.t * 'a) option
            val max_binding : 'a t -> (Interval.t * 'a) option
            val add : 'a t -> Interval.t -> '-> 'a t
            val dominators : 'a t -> Interval.t -> (Interval.t * 'a) Seq.t
            val intersections : 'a t -> Interval.t -> (Interval.t * 'a) Seq.t
            val intersects : 'a t -> Interval.t -> bool
            val dominates : 'a t -> Interval.t -> bool
            val contains : 'a t -> Interval.point -> bool
            val lookup : 'a t -> Interval.point -> (Interval.t * 'a) Seq.t
            val map : 'a t -> f:('-> 'b) -> 'b t
            val mapi : 'a t -> f:(Interval.t -> '-> 'b) -> 'b t
            val filter : 'a t -> f:('-> bool) -> 'a t
            val filter_map : 'a t -> f:('-> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(Interval.t -> '-> 'b option) -> 'b t
            val remove : 'a t -> Interval.t -> 'a t
            val remove_intersections : 'a t -> Interval.t -> 'a t
            val remove_dominators : 'a t -> Interval.t -> 'a t
            val to_sequence : 'a t -> (Interval.t * 'a) Seq.t
            val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val iter : 'a t -> f:('-> unit) -> unit
            val fold :
              'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
            val fold_result :
              'a t ->
              init:'accum ->
              f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val fold_until :
              'a t ->
              init:'accum ->
              f:('accum ->
                 '->
                 ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
              finish:('accum -> 'final) -> 'final
            val exists : 'a t -> f:('-> bool) -> bool
            val for_all : 'a t -> f:('-> bool) -> bool
            val count : 'a t -> f:('-> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              'a t -> f:('-> 'sum) -> 'sum
            val find : 'a t -> f:('-> bool) -> 'a option
            val find_map : 'a t -> f:('-> 'b option) -> 'b option
            val to_list : 'a t -> 'a list
            val to_array : 'a t -> 'a array
            val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
            val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          end
      module type Interval_binable =
        sig
          type t
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          type point
          val bin_point : point Core_kernel.Bin_prot.Type_class.t
          val bin_read_point : point Core_kernel.Bin_prot.Read.reader
          val __bin_read_point__ :
            (int -> point) Core_kernel.Bin_prot.Read.reader
          val bin_reader_point : point Core_kernel.Bin_prot.Type_class.reader
          val bin_size_point : point Core_kernel.Bin_prot.Size.sizer
          val bin_write_point : point Core_kernel.Bin_prot.Write.writer
          val bin_writer_point : point Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_point : Core_kernel.Bin_prot.Shape.t
          val point_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> point
          val compare : t -> t -> int
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          val compare_point : point -> point -> int
          val sexp_of_point : point -> Ppx_sexp_conv_lib.Sexp.t
          val lower : t -> point
          val upper : t -> point
        end
      module type S_binable =
        sig
          type 'a t
          val bin_t :
            'Core_kernel.Bin_prot.Type_class.t ->
            'a t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t :
            'Core_kernel.Bin_prot.Read.reader ->
            'a t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ :
            'Core_kernel.Bin_prot.Read.reader ->
            (int -> 'a t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t :
            'Core_kernel.Bin_prot.Type_class.reader ->
            'a t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t :
            'Core_kernel.Bin_prot.Size.sizer ->
            'a t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t :
            'Core_kernel.Bin_prot.Write.writer ->
            'a t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t :
            'Core_kernel.Bin_prot.Type_class.writer ->
            'a t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t :
            Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          type key
          type point
          val empty : 'a t
          val singleton : key -> '-> 'a t
          val least : 'a t -> point option
          val greatest : 'a t -> point option
          val min_binding : 'a t -> (key * 'a) option
          val max_binding : 'a t -> (key * 'a) option
          val add : 'a t -> key -> '-> 'a t
          val dominators : 'a t -> key -> (key * 'a) Seq.t
          val intersections : 'a t -> key -> (key * 'a) Seq.t
          val intersects : 'a t -> key -> bool
          val dominates : 'a t -> key -> bool
          val contains : 'a t -> point -> bool
          val lookup : 'a t -> point -> (key * 'a) Seq.t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key -> '-> 'b) -> 'b t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi : 'a t -> f:(key -> '-> 'b option) -> 'b t
          val remove : 'a t -> key -> 'a t
          val remove_intersections : 'a t -> key -> 'a t
          val remove_dominators : 'a t -> key -> 'a t
          val to_sequence : 'a t -> (key * 'a) Seq.t
          val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
        end
      module Make_binable :
        functor (Interval : Interval_binable->
          sig
            type 'a t
            val bin_t :
              'Core_kernel.Bin_prot.Type_class.t ->
              'a t Core_kernel.Bin_prot.Type_class.t
            val bin_read_t :
              'Core_kernel.Bin_prot.Read.reader ->
              'a t Core_kernel.Bin_prot.Read.reader
            val __bin_read_t__ :
              'Core_kernel.Bin_prot.Read.reader ->
              (int -> 'a t) Core_kernel.Bin_prot.Read.reader
            val bin_reader_t :
              'Core_kernel.Bin_prot.Type_class.reader ->
              'a t Core_kernel.Bin_prot.Type_class.reader
            val bin_size_t :
              'Core_kernel.Bin_prot.Size.sizer ->
              'a t Core_kernel.Bin_prot.Size.sizer
            val bin_write_t :
              'Core_kernel.Bin_prot.Write.writer ->
              'a t Core_kernel.Bin_prot.Write.writer
            val bin_writer_t :
              'Core_kernel.Bin_prot.Type_class.writer ->
              'a t Core_kernel.Bin_prot.Type_class.writer
            val bin_shape_t :
              Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
            val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            val t_of_sexp :
              (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
              Ppx_sexp_conv_lib.Sexp.t -> 'a t
            val sexp_of_t :
              ('-> Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Ppx_sexp_conv_lib.Sexp.t
            val empty : 'a t
            val singleton : Interval.t -> '-> 'a t
            val least : 'a t -> Interval.point option
            val greatest : 'a t -> Interval.point option
            val min_binding : 'a t -> (Interval.t * 'a) option
            val max_binding : 'a t -> (Interval.t * 'a) option
            val add : 'a t -> Interval.t -> '-> 'a t
            val dominators : 'a t -> Interval.t -> (Interval.t * 'a) Seq.t
            val intersections : 'a t -> Interval.t -> (Interval.t * 'a) Seq.t
            val intersects : 'a t -> Interval.t -> bool
            val dominates : 'a t -> Interval.t -> bool
            val contains : 'a t -> Interval.point -> bool
            val lookup : 'a t -> Interval.point -> (Interval.t * 'a) Seq.t
            val map : 'a t -> f:('-> 'b) -> 'b t
            val mapi : 'a t -> f:(Interval.t -> '-> 'b) -> 'b t
            val filter : 'a t -> f:('-> bool) -> 'a t
            val filter_map : 'a t -> f:('-> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(Interval.t -> '-> 'b option) -> 'b t
            val remove : 'a t -> Interval.t -> 'a t
            val remove_intersections : 'a t -> Interval.t -> 'a t
            val remove_dominators : 'a t -> Interval.t -> 'a t
            val to_sequence : 'a t -> (Interval.t * 'a) Seq.t
            val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val iter : 'a t -> f:('-> unit) -> unit
            val fold :
              'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
            val fold_result :
              'a t ->
              init:'accum ->
              f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val fold_until :
              'a t ->
              init:'accum ->
              f:('accum ->
                 '->
                 ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
              finish:('accum -> 'final) -> 'final
            val exists : 'a t -> f:('-> bool) -> bool
            val for_all : 'a t -> f:('-> bool) -> bool
            val count : 'a t -> f:('-> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              'a t -> f:('-> 'sum) -> 'sum
            val find : 'a t -> f:('-> bool) -> 'a option
            val find_map : 'a t -> f:('-> 'b option) -> 'b option
            val to_list : 'a t -> 'a list
            val to_array : 'a t -> 'a array
            val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
            val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          end
    end
  type value
  val bin_value : value Core_kernel.Bin_prot.Type_class.t
  val bin_read_value : value Core_kernel.Bin_prot.Read.reader
  val __bin_read_value__ : (int -> value) Core_kernel.Bin_prot.Read.reader
  val bin_reader_value : value Core_kernel.Bin_prot.Type_class.reader
  val bin_size_value : value Core_kernel.Bin_prot.Size.sizer
  val bin_write_value : value Core_kernel.Bin_prot.Write.writer
  val bin_writer_value : value Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_value : Core_kernel.Bin_prot.Shape.t
  val compare_value : value -> value -> int
  val value_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> value
  val sexp_of_value : value -> Ppx_sexp_conv_lib.Sexp.t
  type dict
  val bin_dict : dict Core_kernel.Bin_prot.Type_class.t
  val bin_read_dict : dict Core_kernel.Bin_prot.Read.reader
  val __bin_read_dict__ : (int -> dict) Core_kernel.Bin_prot.Read.reader
  val bin_reader_dict : dict Core_kernel.Bin_prot.Type_class.reader
  val bin_size_dict : dict Core_kernel.Bin_prot.Size.sizer
  val bin_write_dict : dict Core_kernel.Bin_prot.Write.writer
  val bin_writer_dict : dict Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_dict : Core_kernel.Bin_prot.Shape.t
  val compare_dict : dict -> dict -> int
  val dict_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> dict
  val sexp_of_dict : dict -> Ppx_sexp_conv_lib.Sexp.t
  type word
  val bin_word : word Core_kernel.Bin_prot.Type_class.t
  val bin_read_word : word Core_kernel.Bin_prot.Read.reader
  val __bin_read_word__ : (int -> word) Core_kernel.Bin_prot.Read.reader
  val bin_reader_word : word Core_kernel.Bin_prot.Type_class.reader
  val bin_size_word : word Core_kernel.Bin_prot.Size.sizer
  val bin_write_word : word Core_kernel.Bin_prot.Write.writer
  val bin_writer_word : word Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_word : Core_kernel.Bin_prot.Shape.t
  val compare_word : word -> word -> int
  val word_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> word
  val sexp_of_word : word -> Ppx_sexp_conv_lib.Sexp.t
  type addr = Bap.Std.word
  val bin_addr : addr Core_kernel.Bin_prot.Type_class.t
  val bin_read_addr : addr Core_kernel.Bin_prot.Read.reader
  val __bin_read_addr__ : (int -> addr) Core_kernel.Bin_prot.Read.reader
  val bin_reader_addr : addr Core_kernel.Bin_prot.Type_class.reader
  val bin_size_addr : addr Core_kernel.Bin_prot.Size.sizer
  val bin_write_addr : addr Core_kernel.Bin_prot.Write.writer
  val bin_writer_addr : addr Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_addr : Core_kernel.Bin_prot.Shape.t
  val compare_addr : addr -> addr -> int
  val addr_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr
  val sexp_of_addr : addr -> Ppx_sexp_conv_lib.Sexp.t
  module Size :
    sig
      type all = [ `r128 | `r16 | `r256 | `r32 | `r64 | `r8 ]
      val r8 : all
      val r16 : all
      val r32 : all
      val r64 : all
      val r128 : all
      val r256 : all
      module Variants_of_all :
        sig
          val r8 : all Variantslib.Variant.t
          val r16 : all Variantslib.Variant.t
          val r32 : all Variantslib.Variant.t
          val r64 : all Variantslib.Variant.t
          val r128 : all Variantslib.Variant.t
          val r256 : all Variantslib.Variant.t
          val fold :
            init:'acc__ ->
            r8:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
            r16:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
            r32:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
            r64:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
            r128:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
            r256:('acc__ -> all Variantslib.Variant.t -> 'acc__) -> 'acc__
          val iter :
            r8:(all Variantslib.Variant.t -> unit) ->
            r16:(all Variantslib.Variant.t -> unit) ->
            r32:(all Variantslib.Variant.t -> unit) ->
            r64:(all Variantslib.Variant.t -> unit) ->
            r128:(all Variantslib.Variant.t -> unit) ->
            r256:(all Variantslib.Variant.t -> unit) -> unit
          val map :
            all ->
            r8:(all Variantslib.Variant.t -> 'result__) ->
            r16:(all Variantslib.Variant.t -> 'result__) ->
            r32:(all Variantslib.Variant.t -> 'result__) ->
            r64:(all Variantslib.Variant.t -> 'result__) ->
            r128:(all Variantslib.Variant.t -> 'result__) ->
            r256:(all Variantslib.Variant.t -> 'result__) -> 'result__
          val to_rank : all -> int
          val to_name : all -> Trie.String.Suffix.key
          val descriptions : (Trie.String.Suffix.key * int) list
        end
      type 'a p = 'constraint 'a = [< Bap.Std.Size.all ]
      val bin_p :
        ([< all ] as 'a) Core_kernel.Bin_prot.Type_class.t ->
        'Core_kernel.Bin_prot.Type_class.t
      val bin_read_p :
        ([< all ] as 'a) Core_kernel.Bin_prot.Read.reader ->
        'Core_kernel.Bin_prot.Read.reader
      val __bin_read_p__ :
        ([< all ] as 'a) Core_kernel.Bin_prot.Read.reader ->
        (int -> 'a) Core_kernel.Bin_prot.Read.reader
      val bin_reader_p :
        ([< all ] as 'a) Core_kernel.Bin_prot.Type_class.reader ->
        'Core_kernel.Bin_prot.Type_class.reader
      val bin_size_p :
        ([< all ] as 'a) Core_kernel.Bin_prot.Size.sizer ->
        'Core_kernel.Bin_prot.Size.sizer
      val bin_write_p :
        ([< all ] as 'a) Core_kernel.Bin_prot.Write.writer ->
        'Core_kernel.Bin_prot.Write.writer
      val bin_writer_p :
        ([< all ] as 'a) Core_kernel.Bin_prot.Type_class.writer ->
        'Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_p :
        Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
      val compare_p : (([< all ] as 'a) -> '-> int) -> '-> '-> int
      val p_of_sexp :
        (Ppx_sexp_conv_lib.Sexp.t -> ([< all ] as 'a)) ->
        Ppx_sexp_conv_lib.Sexp.t -> 'a
      val sexp_of_p :
        (([< all ] as 'a) -> Ppx_sexp_conv_lib.Sexp.t) ->
        '-> Ppx_sexp_conv_lib.Sexp.t
      type t = Bap.Std.Size.all Bap.Std.Size.p
      val of_int : int -> Bap.Std.Size.t Core_kernel.Or_error.t
      val of_int_exn : int -> Bap.Std.Size.t
      val of_int_opt : int -> Bap.Std.Size.t option
      val addr_of_int : int -> [ `r32 | `r64 ] Core_kernel.Or_error.t
      val addr_of_int_exn : int -> [ `r32 | `r64 ]
      val addr_of_int_opt : int -> [ `r32 | `r64 ] option
      val addr_of_word_size : Core_kernel.Word_size.t -> [ `r32 | `r64 ]
      val word_of_addr_size : [ `r32 | `r64 ] -> Core_kernel.Word_size.t
      val to_addr_size :
        Bap.Std.Size.t -> [ `r32 | `r64 ] Core_kernel.Or_error.t
      val in_bits : [< Bap.Std.Size.all ] Bap.Std.Size.p -> int
      val in_bytes : [< Bap.Std.Size.all ] Bap.Std.Size.p -> int
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Core_kernel__.Hashtbl.t -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Core_kernel__.Hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Core_kernel__.Hashtbl.t -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel__.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  type size = Bap.Std.Size.t
  val bin_size : size Core_kernel.Bin_prot.Type_class.t
  val bin_read_size : size Core_kernel.Bin_prot.Read.reader
  val __bin_read_size__ : (int -> size) Core_kernel.Bin_prot.Read.reader
  val bin_reader_size : size Core_kernel.Bin_prot.Type_class.reader
  val bin_size_size : size Core_kernel.Bin_prot.Size.sizer
  val bin_write_size : size Core_kernel.Bin_prot.Write.writer
  val bin_writer_size : size Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_size : Core_kernel.Bin_prot.Shape.t
  val compare_size : size -> size -> int
  val size_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> size
  val sexp_of_size : size -> Ppx_sexp_conv_lib.Sexp.t
  type addr_size = [ `r32 | `r64 ] Bap.Std.Size.p
  val bin_addr_size : addr_size Core_kernel.Bin_prot.Type_class.t
  val bin_read_addr_size : addr_size Core_kernel.Bin_prot.Read.reader
  val __bin_read_addr_size__ :
    (int -> addr_size) Core_kernel.Bin_prot.Read.reader
  val bin_reader_addr_size : addr_size Core_kernel.Bin_prot.Type_class.reader
  val bin_size_addr_size : addr_size Core_kernel.Bin_prot.Size.sizer
  val bin_write_addr_size : addr_size Core_kernel.Bin_prot.Write.writer
  val bin_writer_addr_size : addr_size Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_addr_size : Core_kernel.Bin_prot.Shape.t
  val compare_addr_size : addr_size -> addr_size -> int
  val addr_size_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr_size
  val sexp_of_addr_size : addr_size -> Ppx_sexp_conv_lib.Sexp.t
  module Bitvector :
    sig
      type t = Bap.Std.word
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.word
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Size.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Size.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Size.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Size.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Size.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
      val abs : t -> t
      val neg : t -> t
      val add : t -> t -> t
      val sub : t -> t -> t
      val mul : t -> t -> t
      val div : t -> t -> t
      val modulo : t -> t -> t
      val lnot : t -> t
      val logand : t -> t -> t
      val logor : t -> t -> t
      val logxor : t -> t -> t
      val lshift : t -> t -> t
      val rshift : t -> t -> t
      val arshift : t -> t -> t
      val ( ~- ) : t -> t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      val ( mod ) : t -> t -> t
      val ( land ) : t -> t -> t
      val ( lor ) : t -> t -> t
      val ( lxor ) : t -> t -> t
      val ( lsl ) : t -> t -> t
      val ( lsr ) : t -> t -> t
      val ( asr ) : t -> t -> t
      module Mono :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_increasing_sequence :
                    (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (Key.t, 'a) Table.hashtbl -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:Key.t ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
                  val set : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val find_multi : 'a list t -> Key.t -> 'a list
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Key.t
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Hash_set.elt
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (Elt.t, 'a) Table.hashtbl -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
        end
      type endian = LittleEndian | BigEndian
      val bin_endian : endian Core_kernel.Bin_prot.Type_class.t
      val bin_read_endian : endian Core_kernel.Bin_prot.Read.reader
      val __bin_read_endian__ :
        (int -> endian) Core_kernel.Bin_prot.Read.reader
      val bin_reader_endian : endian Core_kernel.Bin_prot.Type_class.reader
      val bin_size_endian : endian Core_kernel.Bin_prot.Size.sizer
      val bin_write_endian : endian Core_kernel.Bin_prot.Write.writer
      val bin_writer_endian : endian Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_endian : Core_kernel.Bin_prot.Shape.t
      val compare_endian : endian -> endian -> int
      val endian_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> endian
      val sexp_of_endian : endian -> Ppx_sexp_conv_lib.Sexp.t
      val of_string : string -> Bap.Std.Bitvector.t
      val of_bool : bool -> Bap.Std.Bitvector.t
      val of_int : width:int -> int -> Bap.Std.Bitvector.t
      val of_int32 : ?width:int -> int32 -> Bap.Std.Bitvector.t
      val of_int64 : ?width:int -> int64 -> Bap.Std.Bitvector.t
      val b0 : Bap.Std.Bitvector.t
      val b1 : Bap.Std.Bitvector.t
      val one : int -> Bap.Std.Bitvector.t
      val zero : int -> Bap.Std.Bitvector.t
      val ones : int -> Bap.Std.Bitvector.t
      val of_binary :
        ?width:int ->
        Bap.Std.Bitvector.endian -> string -> Bap.Std.Bitvector.t
      val to_int : Bap.Std.Bitvector.t -> int Core_kernel.Or_error.t
      val to_int32 : Bap.Std.Bitvector.t -> int32 Core_kernel.Or_error.t
      val to_int64 : Bap.Std.Bitvector.t -> int64 Core_kernel.Or_error.t
      val to_int_exn : Bap.Std.Bitvector.t -> int
      val to_int32_exn : Bap.Std.Bitvector.t -> int32
      val to_int64_exn : Bap.Std.Bitvector.t -> int64
      val pp : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_hex : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_dec : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_oct : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_bin : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_hex_full : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_dec_full : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_oct_full : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_bin_full : Bap.Std.Bitvector.t Regular.Std.printer
      val pp_generic :
        ?case:[ `lower | `upper ] ->
        ?prefix:[ `auto | `base | `none | `this of string ] ->
        ?suffix:[ `full | `none | `size ] ->
        ?format:[ `bin | `dec | `hex | `oct ] ->
        Bap.Std.Bitvector.t Regular.Std.printer
      val string_of_value : ?hex:bool -> Bap.Std.Bitvector.t -> string
      val signed : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val unsigned : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val is_zero : Bap.Std.Bitvector.t -> bool
      val is_one : Bap.Std.Bitvector.t -> bool
      val bitwidth : Bap.Std.Bitvector.t -> int
      val extract :
        ?hi:int ->
        ?lo:int ->
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
      val extract_exn :
        ?hi:int -> ?lo:int -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val concat :
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val ( @. ) :
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val succ : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val pred : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val nsucc : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
      val npred : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
      val ( ++ ) : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
      val ( -- ) : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
      val gcd :
        Bap.Std.Bitvector.t ->
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
      val lcm :
        Bap.Std.Bitvector.t ->
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
      val gcdext :
        Bap.Std.Bitvector.t ->
        Bap.Std.Bitvector.t ->
        (Bap.Std.Bitvector.t * Bap.Std.Bitvector.t * Bap.Std.Bitvector.t)
        Core_kernel.Or_error.t
      val gcd_exn :
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val lcm_exn :
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
      val gcdext_exn :
        Bap.Std.Bitvector.t ->
        Bap.Std.Bitvector.t ->
        Bap.Std.Bitvector.t * Bap.Std.Bitvector.t * Bap.Std.Bitvector.t
      val enum_bytes :
        Bap.Std.Bitvector.t ->
        Bap.Std.Bitvector.endian -> Bap.Std.Bitvector.t Bap.Std.seq
      val enum_chars :
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.endian -> char Bap.Std.seq
      val enum_bits :
        Bap.Std.Bitvector.t -> Bap.Std.Bitvector.endian -> bool Bap.Std.seq
      val validate_positive : Bap.Std.Bitvector.t Core_kernel.Validate.check
      val validate_non_negative :
        Bap.Std.Bitvector.t Core_kernel.Validate.check
      val validate_negative : Bap.Std.Bitvector.t Core_kernel.Validate.check
      val validate_non_positive :
        Bap.Std.Bitvector.t Core_kernel.Validate.check
      val is_positive : Bap.Std.Bitvector.t -> bool
      val is_non_negative : Bap.Std.Bitvector.t -> bool
      val is_negative : Bap.Std.Bitvector.t -> bool
      val is_non_positive : Bap.Std.Bitvector.t -> bool
      module Int_err :
        sig
          val ( !$ ) :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          val i1 :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          val i4 :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          val i8 :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          val i16 :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          val i32 :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          val i64 :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          val int :
            int ->
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          val of_word_size :
            Core_kernel.Word_size.t ->
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t Core_kernel.Or_error.t
          type t = Hash_set.elt Core_kernel.Or_error.t
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
          val ( >>= ) :
            'Core_kernel.Or_error.t ->
            ('-> 'Core_kernel.Or_error.t) -> 'Core_kernel.Or_error.t
          val ( >>| ) :
            'Core_kernel.Or_error.t ->
            ('-> 'b) -> 'Core_kernel.Or_error.t
        end
      module Int_exn :
        sig
          type t = Hash_set.elt
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
        end
      module Unsafe :
        sig
          type t = Int_exn.t
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
        end
      module Stable :
        sig
          module V1 :
            sig
              type nonrec t = Bap.Std.Bitvector.t
              val bin_t : t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Bin_prot.Shape.t
              val compare : t -> t -> int
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            end
          module V2 :
            sig
              type nonrec t = Bap.Std.Bitvector.t
              val bin_t : t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Bin_prot.Shape.t
              val compare : t -> t -> int
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            end
        end
      module Trie :
        sig
          module Big :
            sig
              module Bits :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = Unsafe.t
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module Bytes :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = Bits.key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
            end
          module Little :
            sig
              module Bits :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = Unsafe.t
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module Bytes :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = Bits.key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
            end
        end
    end
  type endian = Bap.Std.Bitvector.endian = LittleEndian | BigEndian
  val endian_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> endian
  val sexp_of_endian : endian -> Ppx_sexp_conv_lib.Sexp.t
  val bin_endian : endian Core_kernel.Bin_prot.Type_class.t
  val bin_read_endian : endian Core_kernel.Bin_prot.Read.reader
  val __bin_read_endian__ : (int -> endian) Core_kernel.Bin_prot.Read.reader
  val bin_reader_endian : endian Core_kernel.Bin_prot.Type_class.reader
  val bin_size_endian : endian Core_kernel.Bin_prot.Size.sizer
  val bin_write_endian : endian Core_kernel.Bin_prot.Write.writer
  val bin_writer_endian : endian Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_endian : Core_kernel.Bin_prot.Shape.t
  val compare_endian : endian -> endian -> int
  module Word :
    sig
      type t = word
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness = Bitvector.comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = word
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = Bitvector.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (word, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : word -> '-> 'a t
              val of_alist :
                (word * 'a) list -> [ `Duplicate_key of word | `Ok of 'a t ]
              val of_alist_or_error :
                (word * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (word * 'a) list -> 'a t
              val of_alist_multi : (word * 'a) list -> 'a list t
              val of_alist_fold :
                (word * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (word * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (word * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (word * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> word * 'a) -> 'a t
              val of_increasing_sequence :
                (word * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:word -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of word | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (word, 'a) Bitvector.Table.hashtbl -> 'a t
              val gen :
                word Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:word -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:word -> data:'-> 'a t
              val set : 'a t -> key:word -> data:'-> 'a t
              val add_multi : 'a list t -> key:word -> data:'-> 'a list t
              val remove_multi : 'a list t -> word -> 'a list t
              val find_multi : 'a list t -> word -> 'a list
              val change : 'a t -> word -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> word -> 'a option
              val find_exn : 'a t -> word -> 'a
              val remove : 'a t -> word -> 'a t
              val mem : 'a t -> word -> bool
              val iter_keys : 'a t -> f:(word -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:word -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:word ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:word -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:word ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(word -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:word -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:word -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:word -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:word -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> word list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (word * 'a) list
              val validate :
                name:(word -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:word ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (word, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (word * 'a) option
              val min_elt_exn : 'a t -> word * 'a
              val max_elt : 'a t -> (word * 'a) option
              val max_elt_exn : 'a t -> word * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:word -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:word -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:word -> data:'-> bool) -> int
              val split : 'a t -> word -> 'a t * (word * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:word Base__.Maybe_bound.t ->
                upper_bound:word Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:word ->
                max:word ->
                init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:word -> max:word -> (word * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> word -> (word * 'a) option
              val nth : 'a t -> int -> (word * 'a) option
              val nth_exn : 'a t -> int -> word * 'a
              val rank : 'a t -> word -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:word ->
                ?keys_less_or_equal_to:word ->
                'a t -> (word * 'a) Base__.Sequence.t
              val obs :
                word Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                word Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> word
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (word, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : word -> '-> 'a t
          val of_alist :
            (word * 'a) list -> [ `Duplicate_key of word | `Ok of 'a t ]
          val of_alist_or_error : (word * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (word * 'a) list -> 'a t
          val of_alist_multi : (word * 'a) list -> 'a list t
          val of_alist_fold :
            (word * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (word * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (word * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (word * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> word * 'a) -> 'a t
          val of_increasing_sequence :
            (word * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:word -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of word | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (word, 'a) Bitvector.Table.hashtbl -> 'a t
          val gen :
            word Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:word -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:word -> data:'-> 'a t
          val set : 'a t -> key:word -> data:'-> 'a t
          val add_multi : 'a list t -> key:word -> data:'-> 'a list t
          val remove_multi : 'a list t -> word -> 'a list t
          val find_multi : 'a list t -> word -> 'a list
          val change : 'a t -> word -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> word -> 'a option
          val find_exn : 'a t -> word -> 'a
          val remove : 'a t -> word -> 'a t
          val mem : 'a t -> word -> bool
          val iter_keys : 'a t -> f:(word -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:word -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:word ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:word -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:word ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(word -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:word -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:word -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:word -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:word -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> word list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (word * 'a) list
          val validate :
            name:(word -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:word ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (word, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (word * 'a) option
          val min_elt_exn : 'a t -> word * 'a
          val max_elt : 'a t -> (word * 'a) option
          val max_elt_exn : 'a t -> word * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:word -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:word -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:word -> data:'-> bool) -> int
          val split : 'a t -> word -> 'a t * (word * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:word Base__.Maybe_bound.t ->
            upper_bound:word Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:word ->
            max:word -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:word -> max:word -> (word * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> word -> (word * 'a) option
          val nth : 'a t -> int -> (word * 'a) option
          val nth_exn : 'a t -> int -> word * 'a
          val rank : 'a t -> word -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:word ->
            ?keys_less_or_equal_to:word ->
            'a t -> (word * 'a) Base__.Sequence.t
          val obs :
            word Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            word Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> word end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : word Bin_prot.Type_class.t
                       val bin_read_t : word Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> word)
                         Bin_prot.Read.reader
                       val bin_reader_t : word Bin_prot.Type_class.reader
                       val bin_size_t : word Bin_prot.Size.sizer
                       val bin_write_t : word Bin_prot.Write.writer
                       val bin_writer_t : word Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> word -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = word
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Bitvector.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (word, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (word, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(word -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> word -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(word -> bool) -> bool
              val for_all : t -> f:(word -> bool) -> bool
              val count : t -> f:(word -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(word -> 'sum) -> 'sum
              val find : t -> f:(word -> bool) -> word option
              val find_map : t -> f:(word -> 'a option) -> 'a option
              val to_list : t -> word list
              val to_array : t -> word array
              val invariants : t -> bool
              val mem : t -> word -> bool
              val add : t -> word -> t
              val remove : t -> word -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   word -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(word -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of word * word | `Left of word | `Right of word ] ->
                   unit) ->
                unit
              val filter : t -> f:(word -> bool) -> t
              val partition_tf : t -> f:(word -> bool) -> t * t
              val elements : t -> word list
              val min_elt : t -> word option
              val min_elt_exn : t -> word
              val max_elt : t -> word option
              val max_elt_exn : t -> word
              val choose : t -> word option
              val choose_exn : t -> word
              val split : t -> word -> t * word option * t
              val group_by : t -> equiv:(word -> word -> bool) -> t list
              val find_exn : t -> f:(word -> bool) -> word
              val find_index : t -> int -> word option
              val nth : t -> int -> word option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:word ->
                ?less_or_equal_to:word -> t -> word Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:word ->
                ?less_or_equal_to:word ->
                t ->
                t ->
                (word, word) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(word -> 'data) ->
                (word, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                word Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                word Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : word -> t
              val union_list : t list -> t
              val of_list : word list -> t
              val of_array : word array -> t
              val of_sorted_array : word array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : word array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> word) -> t
              val stable_dedup_list : word list -> word list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t -> f:('-> word) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> word option) -> t
              val of_tree : t -> t
              val of_hash_set : word Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (word, 'a) Bitvector.Table.hashtbl -> t
              val of_map_keys :
                (word, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                word Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> word
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (word, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (word, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(word -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> word -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(word -> bool) -> bool
          val for_all : t -> f:(word -> bool) -> bool
          val count : t -> f:(word -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(word -> 'sum) -> 'sum
          val find : t -> f:(word -> bool) -> word option
          val find_map : t -> f:(word -> 'a option) -> 'a option
          val to_list : t -> word list
          val to_array : t -> word array
          val invariants : t -> bool
          val mem : t -> word -> bool
          val add : t -> word -> t
          val remove : t -> word -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> word -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(word -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of word * word | `Left of word | `Right of word ] ->
               unit) ->
            unit
          val filter : t -> f:(word -> bool) -> t
          val partition_tf : t -> f:(word -> bool) -> t * t
          val elements : t -> word list
          val min_elt : t -> word option
          val min_elt_exn : t -> word
          val max_elt : t -> word option
          val max_elt_exn : t -> word
          val choose : t -> word option
          val choose_exn : t -> word
          val split : t -> word -> t * word option * t
          val group_by : t -> equiv:(word -> word -> bool) -> t list
          val find_exn : t -> f:(word -> bool) -> word
          val find_index : t -> int -> word option
          val nth : t -> int -> word option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:word ->
            ?less_or_equal_to:word -> t -> word Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:word ->
            ?less_or_equal_to:word ->
            t ->
            t ->
            (word, word) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(word -> 'data) ->
            (word, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            word Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            word Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : word -> t
          val union_list : t list -> t
          val of_list : word list -> t
          val of_array : word array -> t
          val of_sorted_array : word array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : word array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> word) -> t
          val stable_dedup_list : word list -> word list
          val map : ('a, 'b) Base.Set.t -> f:('-> word) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> word option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : word Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (word, 'a) Bitvector.Table.hashtbl -> t
          val of_map_keys :
            (word, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            word Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> word end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : word Bin_prot.Type_class.t
                       val bin_read_t : word Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> word)
                         Bin_prot.Read.reader
                       val bin_reader_t : word Bin_prot.Type_class.reader
                       val bin_size_t : word Bin_prot.Size.sizer
                       val bin_write_t : word Bin_prot.Write.writer
                       val bin_writer_t : word Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> word -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Bitvector.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = word
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> word -> Core_kernel__.Import.bool
          val lookup : 'a t -> word -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> word -> 'a
          val enqueue : 'a t -> word -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> word -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> word -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> word -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (word * 'a) Core_kernel__.Import.option
          val keys : 'a t -> word Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (word * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> word * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> word -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> word -> Core_kernel__.Import.unit
          val replace : 'a t -> word -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> word -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:word -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:word -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
      val abs : t -> t
      val neg : t -> t
      val add : t -> t -> t
      val sub : t -> t -> t
      val mul : t -> t -> t
      val div : t -> t -> t
      val modulo : t -> t -> t
      val lnot : t -> t
      val logand : t -> t -> t
      val logor : t -> t -> t
      val logxor : t -> t -> t
      val lshift : t -> t -> t
      val rshift : t -> t -> t
      val arshift : t -> t -> t
      val ( ~- ) : t -> t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      val ( mod ) : t -> t -> t
      val ( land ) : t -> t -> t
      val ( lor ) : t -> t -> t
      val ( lxor ) : t -> t -> t
      val ( lsl ) : t -> t -> t
      val ( lsr ) : t -> t -> t
      val ( asr ) : t -> t -> t
      module Mono :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = word
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (word, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : word -> '-> 'a t
                  val of_alist :
                    (word * 'a) list ->
                    [ `Duplicate_key of word | `Ok of 'a t ]
                  val of_alist_or_error :
                    (word * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (word * 'a) list -> 'a t
                  val of_alist_multi : (word * 'a) list -> 'a list t
                  val of_alist_fold :
                    (word * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (word * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (word * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (word * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> word * 'a) -> 'a t
                  val of_increasing_sequence :
                    (word * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:word -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of word | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (word, 'a) Table.hashtbl -> 'a t
                  val gen :
                    word Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:word ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:word -> data:'-> 'a t
                  val set : 'a t -> key:word -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:word -> data:'-> 'a list t
                  val remove_multi : 'a list t -> word -> 'a list t
                  val find_multi : 'a list t -> word -> 'a list
                  val change :
                    'a t -> word -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> word -> 'a option
                  val find_exn : 'a t -> word -> 'a
                  val remove : 'a t -> word -> 'a t
                  val mem : 'a t -> word -> bool
                  val iter_keys : 'a t -> f:(word -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:word -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:word ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:word -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:word ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(word -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:word -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:word -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:word -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:word -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> word list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (word * 'a) list
                  val validate :
                    name:(word -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:word ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (word, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (word * 'a) option
                  val min_elt_exn : 'a t -> word * 'a
                  val max_elt : 'a t -> (word * 'a) option
                  val max_elt_exn : 'a t -> word * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:word -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:word -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:word -> data:'-> bool) -> int
                  val split :
                    'a t -> word -> 'a t * (word * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:word Base__.Maybe_bound.t ->
                    upper_bound:word Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:word ->
                    max:word ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:word -> max:word -> (word * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> word -> (word * 'a) option
                  val nth : 'a t -> int -> (word * 'a) option
                  val nth_exn : 'a t -> int -> word * 'a
                  val rank : 'a t -> word -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:word ->
                    ?keys_less_or_equal_to:word ->
                    'a t -> (word * 'a) Base__.Sequence.t
                  val obs :
                    word Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    word Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> word
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (word, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : word -> '-> 'a t
              val of_alist :
                (word * 'a) list -> [ `Duplicate_key of word | `Ok of 'a t ]
              val of_alist_or_error :
                (word * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (word * 'a) list -> 'a t
              val of_alist_multi : (word * 'a) list -> 'a list t
              val of_alist_fold :
                (word * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (word * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (word * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (word * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> word * 'a) -> 'a t
              val of_increasing_sequence :
                (word * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:word -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of word | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (word, 'a) Table.hashtbl -> 'a t
              val gen :
                word Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:word -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:word -> data:'-> 'a t
              val set : 'a t -> key:word -> data:'-> 'a t
              val add_multi : 'a list t -> key:word -> data:'-> 'a list t
              val remove_multi : 'a list t -> word -> 'a list t
              val find_multi : 'a list t -> word -> 'a list
              val change : 'a t -> word -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> word -> 'a option
              val find_exn : 'a t -> word -> 'a
              val remove : 'a t -> word -> 'a t
              val mem : 'a t -> word -> bool
              val iter_keys : 'a t -> f:(word -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:word -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:word ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:word -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:word ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(word -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:word -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:word -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:word -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:word -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> word list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (word * 'a) list
              val validate :
                name:(word -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:word ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (word, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (word * 'a) option
              val min_elt_exn : 'a t -> word * 'a
              val max_elt : 'a t -> (word * 'a) option
              val max_elt_exn : 'a t -> word * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:word -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:word -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:word -> data:'-> bool) -> int
              val split : 'a t -> word -> 'a t * (word * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:word Base__.Maybe_bound.t ->
                upper_bound:word Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:word ->
                max:word ->
                init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:word -> max:word -> (word * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> word -> (word * 'a) option
              val nth : 'a t -> int -> (word * 'a) option
              val nth_exn : 'a t -> int -> word * 'a
              val rank : 'a t -> word -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:word ->
                ?keys_less_or_equal_to:word ->
                'a t -> (word * 'a) Base__.Sequence.t
              val obs :
                word Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                word Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> word
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : word Bin_prot.Type_class.t
                           val bin_read_t : word Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> word)
                             Bin_prot.Read.reader
                           val bin_reader_t : word Bin_prot.Type_class.reader
                           val bin_size_t : word Bin_prot.Size.sizer
                           val bin_write_t : word Bin_prot.Write.writer
                           val bin_writer_t : word Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> word -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = word
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (word, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (word, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(word -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> word -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(word -> bool) -> bool
                  val for_all : t -> f:(word -> bool) -> bool
                  val count : t -> f:(word -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(word -> 'sum) -> 'sum
                  val find : t -> f:(word -> bool) -> word option
                  val find_map : t -> f:(word -> 'a option) -> 'a option
                  val to_list : t -> word list
                  val to_array : t -> word array
                  val invariants : t -> bool
                  val mem : t -> word -> bool
                  val add : t -> word -> t
                  val remove : t -> word -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       word ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(word -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of word * word
                       | `Left of word
                       | `Right of word ] -> unit) ->
                    unit
                  val filter : t -> f:(word -> bool) -> t
                  val partition_tf : t -> f:(word -> bool) -> t * t
                  val elements : t -> word list
                  val min_elt : t -> word option
                  val min_elt_exn : t -> word
                  val max_elt : t -> word option
                  val max_elt_exn : t -> word
                  val choose : t -> word option
                  val choose_exn : t -> word
                  val split : t -> word -> t * word option * t
                  val group_by : t -> equiv:(word -> word -> bool) -> t list
                  val find_exn : t -> f:(word -> bool) -> word
                  val find_index : t -> int -> word option
                  val nth : t -> int -> word option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:word ->
                    ?less_or_equal_to:word -> t -> word Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:word ->
                    ?less_or_equal_to:word ->
                    t ->
                    t ->
                    (word, word) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(word -> 'data) ->
                    (word, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    word Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    word Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : word -> t
                  val union_list : t list -> t
                  val of_list : word list -> t
                  val of_array : word array -> t
                  val of_sorted_array : word array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : word array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> word) -> t
                  val stable_dedup_list : word list -> word list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> word) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> word option) -> t
                  val of_tree : t -> t
                  val of_hash_set : word Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (word, 'a) Table.hashtbl -> t
                  val of_map_keys :
                    (word, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    word Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> word
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (word, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (word, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(word -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> word -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(word -> bool) -> bool
              val for_all : t -> f:(word -> bool) -> bool
              val count : t -> f:(word -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(word -> 'sum) -> 'sum
              val find : t -> f:(word -> bool) -> word option
              val find_map : t -> f:(word -> 'a option) -> 'a option
              val to_list : t -> word list
              val to_array : t -> word array
              val invariants : t -> bool
              val mem : t -> word -> bool
              val add : t -> word -> t
              val remove : t -> word -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   word -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(word -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of word * word | `Left of word | `Right of word ] ->
                   unit) ->
                unit
              val filter : t -> f:(word -> bool) -> t
              val partition_tf : t -> f:(word -> bool) -> t * t
              val elements : t -> word list
              val min_elt : t -> word option
              val min_elt_exn : t -> word
              val max_elt : t -> word option
              val max_elt_exn : t -> word
              val choose : t -> word option
              val choose_exn : t -> word
              val split : t -> word -> t * word option * t
              val group_by : t -> equiv:(word -> word -> bool) -> t list
              val find_exn : t -> f:(word -> bool) -> word
              val find_index : t -> int -> word option
              val nth : t -> int -> word option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:word ->
                ?less_or_equal_to:word -> t -> word Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:word ->
                ?less_or_equal_to:word ->
                t ->
                t ->
                (word, word) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(word -> 'data) ->
                (word, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                word Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                word Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : word -> t
              val union_list : t list -> t
              val of_list : word list -> t
              val of_array : word array -> t
              val of_sorted_array : word array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : word array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> word) -> t
              val stable_dedup_list : word list -> word list
              val map : ('a, 'b) Base.Set.t -> f:('-> word) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> word option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : word Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (word, 'a) Table.hashtbl -> t
              val of_map_keys :
                (word, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                word Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> word
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : word Bin_prot.Type_class.t
                           val bin_read_t : word Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> word)
                             Bin_prot.Read.reader
                           val bin_reader_t : word Bin_prot.Type_class.reader
                           val bin_size_t : word Bin_prot.Size.sizer
                           val bin_write_t : word Bin_prot.Write.writer
                           val bin_writer_t : word Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> word -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
        end
      type endian = Bap.Std.Bitvector.endian = LittleEndian | BigEndian
      val bin_endian : endian Core_kernel.Bin_prot.Type_class.t
      val bin_read_endian : endian Core_kernel.Bin_prot.Read.reader
      val __bin_read_endian__ :
        (int -> endian) Core_kernel.Bin_prot.Read.reader
      val bin_reader_endian : endian Core_kernel.Bin_prot.Type_class.reader
      val bin_size_endian : endian Core_kernel.Bin_prot.Size.sizer
      val bin_write_endian : endian Core_kernel.Bin_prot.Write.writer
      val bin_writer_endian : endian Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_endian : Core_kernel.Bin_prot.Shape.t
      val compare_endian : endian -> endian -> int
      val endian_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> endian
      val sexp_of_endian : endian -> Ppx_sexp_conv_lib.Sexp.t
      val of_string : Trie.String.Suffix.key -> t
      val of_bool : bool -> t
      val of_int : width:int -> int -> t
      val of_int32 : ?width:int -> int32 -> t
      val of_int64 : ?width:int -> int64 -> t
      val b0 : t
      val b1 : t
      val one : int -> t
      val zero : int -> t
      val ones : int -> t
      val of_binary : ?width:int -> endian -> Trie.String.Suffix.key -> t
      val to_int : t -> int Core_kernel.Or_error.t
      val to_int32 : t -> int32 Core_kernel.Or_error.t
      val to_int64 : t -> int64 Core_kernel.Or_error.t
      val to_int_exn : t -> int
      val to_int32_exn : t -> int32
      val to_int64_exn : t -> int64
      val pp : t Regular.Std.printer
      val pp_hex : t Regular.Std.printer
      val pp_dec : t Regular.Std.printer
      val pp_oct : t Regular.Std.printer
      val pp_bin : t Regular.Std.printer
      val pp_hex_full : t Regular.Std.printer
      val pp_dec_full : t Regular.Std.printer
      val pp_oct_full : t Regular.Std.printer
      val pp_bin_full : t Regular.Std.printer
      val pp_generic :
        ?case:[ `lower | `upper ] ->
        ?prefix:[ `auto | `base | `none | `this of Trie.String.Suffix.key ] ->
        ?suffix:[ `full | `none | `size ] ->
        ?format:[ `bin | `dec | `hex | `oct ] -> t Regular.Std.printer
      val string_of_value : ?hex:bool -> t -> Trie.String.Suffix.key
      val signed : t -> t
      val unsigned : t -> t
      val is_zero : t -> bool
      val is_one : t -> bool
      val bitwidth : t -> int
      val extract : ?hi:int -> ?lo:int -> t -> t Core_kernel.Or_error.t
      val extract_exn : ?hi:int -> ?lo:int -> t -> t
      val concat : t -> t -> t
      val ( @. ) : t -> t -> t
      val succ : t -> t
      val pred : t -> t
      val nsucc : t -> int -> t
      val npred : t -> int -> t
      val ( ++ ) : t -> int -> t
      val ( -- ) : t -> int -> t
      val gcd : t -> t -> t Core_kernel.Or_error.t
      val lcm : t -> t -> t Core_kernel.Or_error.t
      val gcdext : t -> t -> (t * t * t) Core_kernel.Or_error.t
      val gcd_exn : t -> t -> t
      val lcm_exn : t -> t -> t
      val gcdext_exn : t -> t -> t * t * t
      val enum_bytes : t -> endian -> t seq
      val enum_chars : t -> endian -> char seq
      val enum_bits : t -> endian -> bool seq
      val validate_positive : t Core_kernel.Validate.check
      val validate_non_negative : t Core_kernel.Validate.check
      val validate_negative : t Core_kernel.Validate.check
      val validate_non_positive : t Core_kernel.Validate.check
      val is_positive : t -> bool
      val is_non_negative : t -> bool
      val is_negative : t -> bool
      val is_non_positive : t -> bool
      module Int_err :
        sig
          val ( !$ ) : t -> t Core_kernel.Or_error.t
          val i1 : t -> t Core_kernel.Or_error.t
          val i4 : t -> t Core_kernel.Or_error.t
          val i8 : t -> t Core_kernel.Or_error.t
          val i16 : t -> t Core_kernel.Or_error.t
          val i32 : t -> t Core_kernel.Or_error.t
          val i64 : t -> t Core_kernel.Or_error.t
          val int : int -> t -> t Core_kernel.Or_error.t
          val of_word_size :
            Core_kernel.Word_size.t -> t -> t Core_kernel.Or_error.t
          type t = word Core_kernel.Or_error.t
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
          val ( >>= ) :
            'Core_kernel.Or_error.t ->
            ('-> 'Core_kernel.Or_error.t) -> 'Core_kernel.Or_error.t
          val ( >>| ) :
            'Core_kernel.Or_error.t ->
            ('-> 'b) -> 'Core_kernel.Or_error.t
        end
      module Int_exn :
        sig
          type t = word
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
        end
      module Unsafe :
        sig
          type t = word
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
        end
      module Stable :
        sig
          module V1 :
            sig
              type nonrec t = t
              val bin_t : t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Bin_prot.Shape.t
              val compare : t -> t -> int
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            end
          module V2 :
            sig
              type nonrec t = t
              val bin_t : t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Bin_prot.Shape.t
              val compare : t -> t -> int
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            end
        end
      module Trie :
        sig
          module Big :
            sig
              module Bits :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = word
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module Bytes :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = word
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
            end
          module Little :
            sig
              module Bits :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = word
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module Bytes :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = word
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
            end
        end
    end
  module Addr :
    sig
      type t = addr
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness = Word.comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = addr
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = Word.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (addr, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : addr -> '-> 'a t
              val of_alist :
                (addr * 'a) list -> [ `Duplicate_key of addr | `Ok of 'a t ]
              val of_alist_or_error :
                (addr * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (addr * 'a) list -> 'a t
              val of_alist_multi : (addr * 'a) list -> 'a list t
              val of_alist_fold :
                (addr * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (addr * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (addr * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> addr * 'a) -> 'a t
              val of_increasing_sequence :
                (addr * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:addr -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of addr | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (addr, 'a) Word.Table.hashtbl -> 'a t
              val gen :
                addr Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:addr -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:addr -> data:'-> 'a t
              val set : 'a t -> key:addr -> data:'-> 'a t
              val add_multi : 'a list t -> key:addr -> data:'-> 'a list t
              val remove_multi : 'a list t -> addr -> 'a list t
              val find_multi : 'a list t -> addr -> 'a list
              val change : 'a t -> addr -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> addr -> 'a option
              val find_exn : 'a t -> addr -> 'a
              val remove : 'a t -> addr -> 'a t
              val mem : 'a t -> addr -> bool
              val iter_keys : 'a t -> f:(addr -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:addr -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:addr ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:addr -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:addr ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:addr -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:addr -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:addr -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:addr -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> addr list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (addr * 'a) list
              val validate :
                name:(addr -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:addr ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (addr, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (addr * 'a) option
              val min_elt_exn : 'a t -> addr * 'a
              val max_elt : 'a t -> (addr * 'a) option
              val max_elt_exn : 'a t -> addr * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:addr -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:addr -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:addr -> data:'-> bool) -> int
              val split : 'a t -> addr -> 'a t * (addr * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:addr Base__.Maybe_bound.t ->
                upper_bound:addr Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:addr ->
                max:addr ->
                init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:addr -> max:addr -> (addr * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> addr -> (addr * 'a) option
              val nth : 'a t -> int -> (addr * 'a) option
              val nth_exn : 'a t -> int -> addr * 'a
              val rank : 'a t -> addr -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:addr ->
                ?keys_less_or_equal_to:addr ->
                'a t -> (addr * 'a) Base__.Sequence.t
              val obs :
                addr Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                addr Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (addr, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : addr -> '-> 'a t
          val of_alist :
            (addr * 'a) list -> [ `Duplicate_key of addr | `Ok of 'a t ]
          val of_alist_or_error : (addr * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (addr * 'a) list -> 'a t
          val of_alist_multi : (addr * 'a) list -> 'a list t
          val of_alist_fold :
            (addr * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (addr * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (addr * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> addr * 'a) -> 'a t
          val of_increasing_sequence :
            (addr * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:addr -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of addr | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (addr, 'a) Word.Table.hashtbl -> 'a t
          val gen :
            addr Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:addr -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:addr -> data:'-> 'a t
          val set : 'a t -> key:addr -> data:'-> 'a t
          val add_multi : 'a list t -> key:addr -> data:'-> 'a list t
          val remove_multi : 'a list t -> addr -> 'a list t
          val find_multi : 'a list t -> addr -> 'a list
          val change : 'a t -> addr -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> addr -> 'a option
          val find_exn : 'a t -> addr -> 'a
          val remove : 'a t -> addr -> 'a t
          val mem : 'a t -> addr -> bool
          val iter_keys : 'a t -> f:(addr -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:addr -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:addr ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:addr -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:addr ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:addr -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:addr -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:addr -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:addr -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> addr list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (addr * 'a) list
          val validate :
            name:(addr -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:addr ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (addr, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (addr * 'a) option
          val min_elt_exn : 'a t -> addr * 'a
          val max_elt : 'a t -> (addr * 'a) option
          val max_elt_exn : 'a t -> addr * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:addr -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:addr -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:addr -> data:'-> bool) -> int
          val split : 'a t -> addr -> 'a t * (addr * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:addr Base__.Maybe_bound.t ->
            upper_bound:addr Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:addr ->
            max:addr -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:addr -> max:addr -> (addr * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> addr -> (addr * 'a) option
          val nth : 'a t -> int -> (addr * 'a) option
          val nth_exn : 'a t -> int -> addr * 'a
          val rank : 'a t -> addr -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:addr ->
            ?keys_less_or_equal_to:addr ->
            'a t -> (addr * 'a) Base__.Sequence.t
          val obs :
            addr Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            addr Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : addr Bin_prot.Type_class.t
                       val bin_read_t : addr Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> addr)
                         Bin_prot.Read.reader
                       val bin_reader_t : addr Bin_prot.Type_class.reader
                       val bin_size_t : addr Bin_prot.Size.sizer
                       val bin_write_t : addr Bin_prot.Write.writer
                       val bin_writer_t : addr Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> addr -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = addr
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Word.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (addr, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (addr, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(addr -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(addr -> bool) -> bool
              val for_all : t -> f:(addr -> bool) -> bool
              val count : t -> f:(addr -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(addr -> 'sum) -> 'sum
              val find : t -> f:(addr -> bool) -> addr option
              val find_map : t -> f:(addr -> 'a option) -> 'a option
              val to_list : t -> addr list
              val to_array : t -> addr array
              val invariants : t -> bool
              val mem : t -> addr -> bool
              val add : t -> addr -> t
              val remove : t -> addr -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   addr -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(addr -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of addr * addr | `Left of addr | `Right of addr ] ->
                   unit) ->
                unit
              val filter : t -> f:(addr -> bool) -> t
              val partition_tf : t -> f:(addr -> bool) -> t * t
              val elements : t -> addr list
              val min_elt : t -> addr option
              val min_elt_exn : t -> addr
              val max_elt : t -> addr option
              val max_elt_exn : t -> addr
              val choose : t -> addr option
              val choose_exn : t -> addr
              val split : t -> addr -> t * addr option * t
              val group_by : t -> equiv:(addr -> addr -> bool) -> t list
              val find_exn : t -> f:(addr -> bool) -> addr
              val find_index : t -> int -> addr option
              val nth : t -> int -> addr option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:addr ->
                ?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:addr ->
                ?less_or_equal_to:addr ->
                t ->
                t ->
                (addr, addr) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(addr -> 'data) ->
                (addr, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                addr Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                addr Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : addr -> t
              val union_list : t list -> t
              val of_list : addr list -> t
              val of_array : addr array -> t
              val of_sorted_array : addr array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : addr array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> addr) -> t
              val stable_dedup_list : addr list -> addr list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t -> f:('-> addr) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> addr option) -> t
              val of_tree : t -> t
              val of_hash_set : addr Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (addr, 'a) Word.Table.hashtbl -> t
              val of_map_keys :
                (addr, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                addr Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (addr, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (addr, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(addr -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(addr -> bool) -> bool
          val for_all : t -> f:(addr -> bool) -> bool
          val count : t -> f:(addr -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(addr -> 'sum) -> 'sum
          val find : t -> f:(addr -> bool) -> addr option
          val find_map : t -> f:(addr -> 'a option) -> 'a option
          val to_list : t -> addr list
          val to_array : t -> addr array
          val invariants : t -> bool
          val mem : t -> addr -> bool
          val add : t -> addr -> t
          val remove : t -> addr -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> addr -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(addr -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of addr * addr | `Left of addr | `Right of addr ] ->
               unit) ->
            unit
          val filter : t -> f:(addr -> bool) -> t
          val partition_tf : t -> f:(addr -> bool) -> t * t
          val elements : t -> addr list
          val min_elt : t -> addr option
          val min_elt_exn : t -> addr
          val max_elt : t -> addr option
          val max_elt_exn : t -> addr
          val choose : t -> addr option
          val choose_exn : t -> addr
          val split : t -> addr -> t * addr option * t
          val group_by : t -> equiv:(addr -> addr -> bool) -> t list
          val find_exn : t -> f:(addr -> bool) -> addr
          val find_index : t -> int -> addr option
          val nth : t -> int -> addr option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:addr ->
            ?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:addr ->
            ?less_or_equal_to:addr ->
            t ->
            t ->
            (addr, addr) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(addr -> 'data) ->
            (addr, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            addr Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            addr Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : addr -> t
          val union_list : t list -> t
          val of_list : addr list -> t
          val of_array : addr array -> t
          val of_sorted_array : addr array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : addr array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> addr) -> t
          val stable_dedup_list : addr list -> addr list
          val map : ('a, 'b) Base.Set.t -> f:('-> addr) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> addr option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : addr Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (addr, 'a) Word.Table.hashtbl -> t
          val of_map_keys :
            (addr, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            addr Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : addr Bin_prot.Type_class.t
                       val bin_read_t : addr Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> addr)
                         Bin_prot.Read.reader
                       val bin_reader_t : addr Bin_prot.Type_class.reader
                       val bin_size_t : addr Bin_prot.Size.sizer
                       val bin_write_t : addr Bin_prot.Write.writer
                       val bin_writer_t : addr Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> addr -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Word.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = addr
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> addr -> Core_kernel__.Import.bool
          val lookup : 'a t -> addr -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> addr -> 'a
          val enqueue : 'a t -> addr -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> addr -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> addr -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> addr -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (addr * 'a) Core_kernel__.Import.option
          val keys : 'a t -> addr Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (addr * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> addr * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> addr -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> addr -> Core_kernel__.Import.unit
          val replace : 'a t -> addr -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> addr -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:addr -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:addr -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
      val abs : t -> t
      val neg : t -> t
      val add : t -> t -> t
      val sub : t -> t -> t
      val mul : t -> t -> t
      val div : t -> t -> t
      val modulo : t -> t -> t
      val lnot : t -> t
      val logand : t -> t -> t
      val logor : t -> t -> t
      val logxor : t -> t -> t
      val lshift : t -> t -> t
      val rshift : t -> t -> t
      val arshift : t -> t -> t
      val ( ~- ) : t -> t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      val ( mod ) : t -> t -> t
      val ( land ) : t -> t -> t
      val ( lor ) : t -> t -> t
      val ( lxor ) : t -> t -> t
      val ( lsl ) : t -> t -> t
      val ( lsr ) : t -> t -> t
      val ( asr ) : t -> t -> t
      module Mono :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = addr
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (addr, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : addr -> '-> 'a t
                  val of_alist :
                    (addr * 'a) list ->
                    [ `Duplicate_key of addr | `Ok of 'a t ]
                  val of_alist_or_error :
                    (addr * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (addr * 'a) list -> 'a t
                  val of_alist_multi : (addr * 'a) list -> 'a list t
                  val of_alist_fold :
                    (addr * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (addr * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (addr * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> addr * 'a) -> 'a t
                  val of_increasing_sequence :
                    (addr * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:addr -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of addr | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (addr, 'a) Table.hashtbl -> 'a t
                  val gen :
                    addr Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:addr ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:addr -> data:'-> 'a t
                  val set : 'a t -> key:addr -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:addr -> data:'-> 'a list t
                  val remove_multi : 'a list t -> addr -> 'a list t
                  val find_multi : 'a list t -> addr -> 'a list
                  val change :
                    'a t -> addr -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> addr -> 'a option
                  val find_exn : 'a t -> addr -> 'a
                  val remove : 'a t -> addr -> 'a t
                  val mem : 'a t -> addr -> bool
                  val iter_keys : 'a t -> f:(addr -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:addr -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:addr ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:addr -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:addr ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:addr -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:addr -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:addr -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:addr -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> addr list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (addr * 'a) list
                  val validate :
                    name:(addr -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:addr ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (addr, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (addr * 'a) option
                  val min_elt_exn : 'a t -> addr * 'a
                  val max_elt : 'a t -> (addr * 'a) option
                  val max_elt_exn : 'a t -> addr * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:addr -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:addr -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:addr -> data:'-> bool) -> int
                  val split :
                    'a t -> addr -> 'a t * (addr * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:addr Base__.Maybe_bound.t ->
                    upper_bound:addr Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:addr ->
                    max:addr ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:addr -> max:addr -> (addr * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> addr -> (addr * 'a) option
                  val nth : 'a t -> int -> (addr * 'a) option
                  val nth_exn : 'a t -> int -> addr * 'a
                  val rank : 'a t -> addr -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:addr ->
                    ?keys_less_or_equal_to:addr ->
                    'a t -> (addr * 'a) Base__.Sequence.t
                  val obs :
                    addr Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    addr Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (addr, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : addr -> '-> 'a t
              val of_alist :
                (addr * 'a) list -> [ `Duplicate_key of addr | `Ok of 'a t ]
              val of_alist_or_error :
                (addr * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (addr * 'a) list -> 'a t
              val of_alist_multi : (addr * 'a) list -> 'a list t
              val of_alist_fold :
                (addr * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (addr * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (addr * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> addr * 'a) -> 'a t
              val of_increasing_sequence :
                (addr * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:addr -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of addr | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (addr, 'a) Table.hashtbl -> 'a t
              val gen :
                addr Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:addr -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:addr -> data:'-> 'a t
              val set : 'a t -> key:addr -> data:'-> 'a t
              val add_multi : 'a list t -> key:addr -> data:'-> 'a list t
              val remove_multi : 'a list t -> addr -> 'a list t
              val find_multi : 'a list t -> addr -> 'a list
              val change : 'a t -> addr -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> addr -> 'a option
              val find_exn : 'a t -> addr -> 'a
              val remove : 'a t -> addr -> 'a t
              val mem : 'a t -> addr -> bool
              val iter_keys : 'a t -> f:(addr -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:addr -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:addr ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:addr -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:addr ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:addr -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:addr -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:addr -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:addr -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> addr list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (addr * 'a) list
              val validate :
                name:(addr -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:addr ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (addr, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (addr * 'a) option
              val min_elt_exn : 'a t -> addr * 'a
              val max_elt : 'a t -> (addr * 'a) option
              val max_elt_exn : 'a t -> addr * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:addr -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:addr -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:addr -> data:'-> bool) -> int
              val split : 'a t -> addr -> 'a t * (addr * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:addr Base__.Maybe_bound.t ->
                upper_bound:addr Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:addr ->
                max:addr ->
                init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:addr -> max:addr -> (addr * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> addr -> (addr * 'a) option
              val nth : 'a t -> int -> (addr * 'a) option
              val nth_exn : 'a t -> int -> addr * 'a
              val rank : 'a t -> addr -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:addr ->
                ?keys_less_or_equal_to:addr ->
                'a t -> (addr * 'a) Base__.Sequence.t
              val obs :
                addr Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                addr Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : addr Bin_prot.Type_class.t
                           val bin_read_t : addr Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> addr)
                             Bin_prot.Read.reader
                           val bin_reader_t : addr Bin_prot.Type_class.reader
                           val bin_size_t : addr Bin_prot.Size.sizer
                           val bin_write_t : addr Bin_prot.Write.writer
                           val bin_writer_t : addr Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> addr -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = addr
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (addr, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (addr, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(addr -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(addr -> bool) -> bool
                  val for_all : t -> f:(addr -> bool) -> bool
                  val count : t -> f:(addr -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(addr -> 'sum) -> 'sum
                  val find : t -> f:(addr -> bool) -> addr option
                  val find_map : t -> f:(addr -> 'a option) -> 'a option
                  val to_list : t -> addr list
                  val to_array : t -> addr array
                  val invariants : t -> bool
                  val mem : t -> addr -> bool
                  val add : t -> addr -> t
                  val remove : t -> addr -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       addr ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(addr -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of addr * addr
                       | `Left of addr
                       | `Right of addr ] -> unit) ->
                    unit
                  val filter : t -> f:(addr -> bool) -> t
                  val partition_tf : t -> f:(addr -> bool) -> t * t
                  val elements : t -> addr list
                  val min_elt : t -> addr option
                  val min_elt_exn : t -> addr
                  val max_elt : t -> addr option
                  val max_elt_exn : t -> addr
                  val choose : t -> addr option
                  val choose_exn : t -> addr
                  val split : t -> addr -> t * addr option * t
                  val group_by : t -> equiv:(addr -> addr -> bool) -> t list
                  val find_exn : t -> f:(addr -> bool) -> addr
                  val find_index : t -> int -> addr option
                  val nth : t -> int -> addr option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:addr ->
                    ?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:addr ->
                    ?less_or_equal_to:addr ->
                    t ->
                    t ->
                    (addr, addr) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(addr -> 'data) ->
                    (addr, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    addr Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    addr Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : addr -> t
                  val union_list : t list -> t
                  val of_list : addr list -> t
                  val of_array : addr array -> t
                  val of_sorted_array : addr array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : addr array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> addr) -> t
                  val stable_dedup_list : addr list -> addr list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> addr) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> addr option) -> t
                  val of_tree : t -> t
                  val of_hash_set : addr Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (addr, 'a) Table.hashtbl -> t
                  val of_map_keys :
                    (addr, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    addr Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> addr
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (addr, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (addr, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(addr -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(addr -> bool) -> bool
              val for_all : t -> f:(addr -> bool) -> bool
              val count : t -> f:(addr -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(addr -> 'sum) -> 'sum
              val find : t -> f:(addr -> bool) -> addr option
              val find_map : t -> f:(addr -> 'a option) -> 'a option
              val to_list : t -> addr list
              val to_array : t -> addr array
              val invariants : t -> bool
              val mem : t -> addr -> bool
              val add : t -> addr -> t
              val remove : t -> addr -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   addr -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(addr -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of addr * addr | `Left of addr | `Right of addr ] ->
                   unit) ->
                unit
              val filter : t -> f:(addr -> bool) -> t
              val partition_tf : t -> f:(addr -> bool) -> t * t
              val elements : t -> addr list
              val min_elt : t -> addr option
              val min_elt_exn : t -> addr
              val max_elt : t -> addr option
              val max_elt_exn : t -> addr
              val choose : t -> addr option
              val choose_exn : t -> addr
              val split : t -> addr -> t * addr option * t
              val group_by : t -> equiv:(addr -> addr -> bool) -> t list
              val find_exn : t -> f:(addr -> bool) -> addr
              val find_index : t -> int -> addr option
              val nth : t -> int -> addr option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:addr ->
                ?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:addr ->
                ?less_or_equal_to:addr ->
                t ->
                t ->
                (addr, addr) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(addr -> 'data) ->
                (addr, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                addr Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                addr Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : addr -> t
              val union_list : t list -> t
              val of_list : addr list -> t
              val of_array : addr array -> t
              val of_sorted_array : addr array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : addr array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> addr) -> t
              val stable_dedup_list : addr list -> addr list
              val map : ('a, 'b) Base.Set.t -> f:('-> addr) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> addr option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : addr Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (addr, 'a) Table.hashtbl -> t
              val of_map_keys :
                (addr, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                addr Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : addr Bin_prot.Type_class.t
                           val bin_read_t : addr Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> addr)
                             Bin_prot.Read.reader
                           val bin_reader_t : addr Bin_prot.Type_class.reader
                           val bin_size_t : addr Bin_prot.Size.sizer
                           val bin_write_t : addr Bin_prot.Write.writer
                           val bin_writer_t : addr Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> addr -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
        end
      type endian = Word.endian = LittleEndian | BigEndian
      val bin_endian : endian Core_kernel.Bin_prot.Type_class.t
      val bin_read_endian : endian Core_kernel.Bin_prot.Read.reader
      val __bin_read_endian__ :
        (int -> endian) Core_kernel.Bin_prot.Read.reader
      val bin_reader_endian : endian Core_kernel.Bin_prot.Type_class.reader
      val bin_size_endian : endian Core_kernel.Bin_prot.Size.sizer
      val bin_write_endian : endian Core_kernel.Bin_prot.Write.writer
      val bin_writer_endian : endian Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_endian : Core_kernel.Bin_prot.Shape.t
      val compare_endian : endian -> endian -> int
      val endian_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> endian
      val sexp_of_endian : endian -> Ppx_sexp_conv_lib.Sexp.t
      val of_string : Trie.String.Suffix.key -> t
      val of_bool : bool -> t
      val of_int : width:int -> int -> t
      val of_int32 : ?width:int -> int32 -> t
      val of_int64 : ?width:int -> int64 -> t
      val b0 : t
      val b1 : t
      val one : int -> t
      val zero : int -> t
      val ones : int -> t
      val of_binary : ?width:int -> endian -> Trie.String.Suffix.key -> t
      val to_int : t -> int Core_kernel.Or_error.t
      val to_int32 : t -> int32 Core_kernel.Or_error.t
      val to_int64 : t -> int64 Core_kernel.Or_error.t
      val to_int_exn : t -> int
      val to_int32_exn : t -> int32
      val to_int64_exn : t -> int64
      val pp : t Regular.Std.printer
      val pp_hex : t Regular.Std.printer
      val pp_dec : t Regular.Std.printer
      val pp_oct : t Regular.Std.printer
      val pp_bin : t Regular.Std.printer
      val pp_hex_full : t Regular.Std.printer
      val pp_dec_full : t Regular.Std.printer
      val pp_oct_full : t Regular.Std.printer
      val pp_bin_full : t Regular.Std.printer
      val pp_generic :
        ?case:[ `lower | `upper ] ->
        ?prefix:[ `auto | `base | `none | `this of Trie.String.Suffix.key ] ->
        ?suffix:[ `full | `none | `size ] ->
        ?format:[ `bin | `dec | `hex | `oct ] -> t Regular.Std.printer
      val string_of_value : ?hex:bool -> t -> Trie.String.Suffix.key
      val signed : t -> t
      val unsigned : t -> t
      val is_zero : t -> bool
      val is_one : t -> bool
      val bitwidth : t -> int
      val extract : ?hi:int -> ?lo:int -> t -> t Core_kernel.Or_error.t
      val extract_exn : ?hi:int -> ?lo:int -> t -> t
      val concat : t -> t -> t
      val ( @. ) : t -> t -> t
      val succ : t -> t
      val pred : t -> t
      val nsucc : t -> int -> t
      val npred : t -> int -> t
      val ( ++ ) : t -> int -> t
      val ( -- ) : t -> int -> t
      val gcd : t -> t -> t Core_kernel.Or_error.t
      val lcm : t -> t -> t Core_kernel.Or_error.t
      val gcdext : t -> t -> (t * t * t) Core_kernel.Or_error.t
      val gcd_exn : t -> t -> t
      val lcm_exn : t -> t -> t
      val gcdext_exn : t -> t -> t * t * t
      val enum_bytes : t -> endian -> t seq
      val enum_chars : t -> endian -> char seq
      val enum_bits : t -> endian -> bool seq
      val validate_positive : t Core_kernel.Validate.check
      val validate_non_negative : t Core_kernel.Validate.check
      val validate_negative : t Core_kernel.Validate.check
      val validate_non_positive : t Core_kernel.Validate.check
      val is_positive : t -> bool
      val is_non_negative : t -> bool
      val is_negative : t -> bool
      val is_non_positive : t -> bool
      module Int_err :
        sig
          val ( !$ ) : t -> t Core_kernel.Or_error.t
          val i1 : t -> t Core_kernel.Or_error.t
          val i4 : t -> t Core_kernel.Or_error.t
          val i8 : t -> t Core_kernel.Or_error.t
          val i16 : t -> t Core_kernel.Or_error.t
          val i32 : t -> t Core_kernel.Or_error.t
          val i64 : t -> t Core_kernel.Or_error.t
          val int : int -> t -> t Core_kernel.Or_error.t
          val of_word_size :
            Core_kernel.Word_size.t -> t -> t Core_kernel.Or_error.t
          type t = addr Core_kernel.Or_error.t
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
          val ( >>= ) :
            'Core_kernel.Or_error.t ->
            ('-> 'Core_kernel.Or_error.t) -> 'Core_kernel.Or_error.t
          val ( >>| ) :
            'Core_kernel.Or_error.t ->
            ('-> 'b) -> 'Core_kernel.Or_error.t
        end
      module Int_exn :
        sig
          type t = addr
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
        end
      module Unsafe :
        sig
          type t = addr
          val zero : t
          val one : t
          val succ : t -> t
          val pred : t -> t
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
        end
      module Stable :
        sig
          module V1 :
            sig
              type nonrec t = t
              val bin_t : t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Bin_prot.Shape.t
              val compare : t -> t -> int
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            end
          module V2 :
            sig
              type nonrec t = t
              val bin_t : t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Bin_prot.Shape.t
              val compare : t -> t -> int
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            end
        end
      module Trie :
        sig
          module Big :
            sig
              module Bits :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = addr
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module Bytes :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = addr
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
            end
          module Little :
            sig
              module Bits :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = addr
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module Bytes :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = addr
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
            end
        end
      val memref :
        ?disp:int ->
        ?index:int -> ?scale:Bap.Std.size -> Bap.Std.addr -> Bap.Std.addr
    end
  module Bil :
    sig
      module Types :
        sig
          type var
          type cast = UNSIGNED | SIGNED | HIGH | LOW
          val bin_cast : cast Core_kernel.Bin_prot.Type_class.t
          val bin_read_cast : cast Core_kernel.Bin_prot.Read.reader
          val __bin_read_cast__ :
            (int -> cast) Core_kernel.Bin_prot.Read.reader
          val bin_reader_cast : cast Core_kernel.Bin_prot.Type_class.reader
          val bin_size_cast : cast Core_kernel.Bin_prot.Size.sizer
          val bin_write_cast : cast Core_kernel.Bin_prot.Write.writer
          val bin_writer_cast : cast Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_cast : Core_kernel.Bin_prot.Shape.t
          val compare_cast : cast -> cast -> int
          val cast_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cast
          val sexp_of_cast : cast -> Ppx_sexp_conv_lib.Sexp.t
          type binop =
              PLUS
            | MINUS
            | TIMES
            | DIVIDE
            | SDIVIDE
            | MOD
            | SMOD
            | LSHIFT
            | RSHIFT
            | ARSHIFT
            | AND
            | OR
            | XOR
            | EQ
            | NEQ
            | LT
            | LE
            | SLT
            | SLE
          val bin_binop : binop Core_kernel.Bin_prot.Type_class.t
          val bin_read_binop : binop Core_kernel.Bin_prot.Read.reader
          val __bin_read_binop__ :
            (int -> binop) Core_kernel.Bin_prot.Read.reader
          val bin_reader_binop : binop Core_kernel.Bin_prot.Type_class.reader
          val bin_size_binop : binop Core_kernel.Bin_prot.Size.sizer
          val bin_write_binop : binop Core_kernel.Bin_prot.Write.writer
          val bin_writer_binop : binop Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_binop : Core_kernel.Bin_prot.Shape.t
          val compare_binop : binop -> binop -> int
          val binop_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> binop
          val sexp_of_binop : binop -> Ppx_sexp_conv_lib.Sexp.t
          type unop = NEG | NOT
          val bin_unop : unop Core_kernel.Bin_prot.Type_class.t
          val bin_read_unop : unop Core_kernel.Bin_prot.Read.reader
          val __bin_read_unop__ :
            (int -> unop) Core_kernel.Bin_prot.Read.reader
          val bin_reader_unop : unop Core_kernel.Bin_prot.Type_class.reader
          val bin_size_unop : unop Core_kernel.Bin_prot.Size.sizer
          val bin_write_unop : unop Core_kernel.Bin_prot.Write.writer
          val bin_writer_unop : unop Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_unop : Core_kernel.Bin_prot.Shape.t
          val compare_unop : unop -> unop -> int
          val unop_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> unop
          val sexp_of_unop : unop -> Ppx_sexp_conv_lib.Sexp.t
          type exp =
              Load of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
                Bap.Std.endian * Bap.Std.size
            | Store of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
                Bap.Std.Bil.Types.exp * Bap.Std.endian * Bap.Std.size
            | BinOp of Bap.Std.Bil.Types.binop * Bap.Std.Bil.Types.exp *
                Bap.Std.Bil.Types.exp
            | UnOp of Bap.Std.Bil.Types.unop * Bap.Std.Bil.Types.exp
            | Var of Bap.Std.Bil.Types.var
            | Int of Bap.Std.word
            | Cast of Bap.Std.Bil.Types.cast * int * Bap.Std.Bil.Types.exp
            | Let of Bap.Std.Bil.Types.var * Bap.Std.Bil.Types.exp *
                Bap.Std.Bil.Types.exp
            | Unknown of string * Bap.Std.Bil.Types.typ
            | Ite of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
                Bap.Std.Bil.Types.exp
            | Extract of int * int * Bap.Std.Bil.Types.exp
            | Concat of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp
          and typ = Imm of int | Mem of Bap.Std.addr_size * Bap.Std.size
          val bin_exp : exp Core_kernel.Bin_prot.Type_class.t
          val bin_typ : typ Core_kernel.Bin_prot.Type_class.t
          val bin_read_exp : exp Core_kernel.Bin_prot.Read.reader
          val __bin_read_exp__ :
            (int -> exp) Core_kernel.Bin_prot.Read.reader
          val bin_reader_exp : exp Core_kernel.Bin_prot.Type_class.reader
          val bin_read_typ : typ Core_kernel.Bin_prot.Read.reader
          val __bin_read_typ__ :
            (int -> typ) Core_kernel.Bin_prot.Read.reader
          val bin_reader_typ : typ Core_kernel.Bin_prot.Type_class.reader
          val bin_size_exp : exp Core_kernel.Bin_prot.Size.sizer
          val bin_write_exp : exp Core_kernel.Bin_prot.Write.writer
          val bin_writer_exp : exp Core_kernel.Bin_prot.Type_class.writer
          val bin_size_typ : typ Core_kernel.Bin_prot.Size.sizer
          val bin_write_typ : typ Core_kernel.Bin_prot.Write.writer
          val bin_writer_typ : typ Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_exp : Core_kernel.Bin_prot.Shape.t
          val bin_shape_typ : Core_kernel.Bin_prot.Shape.t
          val compare_exp : exp -> exp -> int
          val compare_typ : typ -> typ -> int
          val exp_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> exp
          val typ_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> typ
          val sexp_of_exp : exp -> Ppx_sexp_conv_lib.Sexp.t
          val sexp_of_typ : typ -> Ppx_sexp_conv_lib.Sexp.t
          type stmt =
              Move of Bap.Std.Bil.Types.var * Bap.Std.Bil.Types.exp
            | Jmp of Bap.Std.Bil.Types.exp
            | Special of string
            | While of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.stmt list
            | If of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.stmt list *
                Bap.Std.Bil.Types.stmt list
            | CpuExn of int
          val bin_stmt : stmt Core_kernel.Bin_prot.Type_class.t
          val bin_read_stmt : stmt Core_kernel.Bin_prot.Read.reader
          val __bin_read_stmt__ :
            (int -> stmt) Core_kernel.Bin_prot.Read.reader
          val bin_reader_stmt : stmt Core_kernel.Bin_prot.Type_class.reader
          val bin_size_stmt : stmt Core_kernel.Bin_prot.Size.sizer
          val bin_write_stmt : stmt Core_kernel.Bin_prot.Write.writer
          val bin_writer_stmt : stmt Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_stmt : Core_kernel.Bin_prot.Shape.t
          val compare_stmt : stmt -> stmt -> int
          val stmt_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> stmt
          val sexp_of_stmt : stmt -> Ppx_sexp_conv_lib.Sexp.t
        end
      type var = Types.var
      type cast = Types.cast = UNSIGNED | SIGNED | HIGH | LOW
      val bin_cast : cast Core_kernel.Bin_prot.Type_class.t
      val bin_read_cast : cast Core_kernel.Bin_prot.Read.reader
      val __bin_read_cast__ : (int -> cast) Core_kernel.Bin_prot.Read.reader
      val bin_reader_cast : cast Core_kernel.Bin_prot.Type_class.reader
      val bin_size_cast : cast Core_kernel.Bin_prot.Size.sizer
      val bin_write_cast : cast Core_kernel.Bin_prot.Write.writer
      val bin_writer_cast : cast Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_cast : Core_kernel.Bin_prot.Shape.t
      val compare_cast : cast -> cast -> int
      val cast_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cast
      val sexp_of_cast : cast -> Ppx_sexp_conv_lib.Sexp.t
      type binop =
        Types.binop =
          PLUS
        | MINUS
        | TIMES
        | DIVIDE
        | SDIVIDE
        | MOD
        | SMOD
        | LSHIFT
        | RSHIFT
        | ARSHIFT
        | AND
        | OR
        | XOR
        | EQ
        | NEQ
        | LT
        | LE
        | SLT
        | SLE
      val bin_binop : binop Core_kernel.Bin_prot.Type_class.t
      val bin_read_binop : binop Core_kernel.Bin_prot.Read.reader
      val __bin_read_binop__ :
        (int -> binop) Core_kernel.Bin_prot.Read.reader
      val bin_reader_binop : binop Core_kernel.Bin_prot.Type_class.reader
      val bin_size_binop : binop Core_kernel.Bin_prot.Size.sizer
      val bin_write_binop : binop Core_kernel.Bin_prot.Write.writer
      val bin_writer_binop : binop Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_binop : Core_kernel.Bin_prot.Shape.t
      val compare_binop : binop -> binop -> int
      val binop_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> binop
      val sexp_of_binop : binop -> Ppx_sexp_conv_lib.Sexp.t
      type unop = Types.unop = NEG | NOT
      val bin_unop : unop Core_kernel.Bin_prot.Type_class.t
      val bin_read_unop : unop Core_kernel.Bin_prot.Read.reader
      val __bin_read_unop__ : (int -> unop) Core_kernel.Bin_prot.Read.reader
      val bin_reader_unop : unop Core_kernel.Bin_prot.Type_class.reader
      val bin_size_unop : unop Core_kernel.Bin_prot.Size.sizer
      val bin_write_unop : unop Core_kernel.Bin_prot.Write.writer
      val bin_writer_unop : unop Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_unop : Core_kernel.Bin_prot.Shape.t
      val compare_unop : unop -> unop -> int
      val unop_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> unop
      val sexp_of_unop : unop -> Ppx_sexp_conv_lib.Sexp.t
      type exp =
        Types.exp =
          Load of exp * exp * endian * size
        | Store of exp * exp * exp * endian * size
        | BinOp of binop * exp * exp
        | UnOp of unop * exp
        | Var of var
        | Int of word
        | Cast of cast * int * exp
        | Let of var * exp * exp
        | Unknown of Trie.String.Suffix.key * typ
        | Ite of exp * exp * exp
        | Extract of int * int * exp
        | Concat of exp * exp
      and typ = Types.typ = Imm of int | Mem of addr_size * size
      val bin_exp : exp Core_kernel.Bin_prot.Type_class.t
      val bin_typ : typ Core_kernel.Bin_prot.Type_class.t
      val bin_read_exp : exp Core_kernel.Bin_prot.Read.reader
      val __bin_read_exp__ : (int -> exp) Core_kernel.Bin_prot.Read.reader
      val bin_reader_exp : exp Core_kernel.Bin_prot.Type_class.reader
      val bin_read_typ : typ Core_kernel.Bin_prot.Read.reader
      val __bin_read_typ__ : (int -> typ) Core_kernel.Bin_prot.Read.reader
      val bin_reader_typ : typ Core_kernel.Bin_prot.Type_class.reader
      val bin_size_exp : exp Core_kernel.Bin_prot.Size.sizer
      val bin_write_exp : exp Core_kernel.Bin_prot.Write.writer
      val bin_writer_exp : exp Core_kernel.Bin_prot.Type_class.writer
      val bin_size_typ : typ Core_kernel.Bin_prot.Size.sizer
      val bin_write_typ : typ Core_kernel.Bin_prot.Write.writer
      val bin_writer_typ : typ Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_exp : Core_kernel.Bin_prot.Shape.t
      val bin_shape_typ : Core_kernel.Bin_prot.Shape.t
      val compare_exp : exp -> exp -> int
      val compare_typ : typ -> typ -> int
      val exp_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> exp
      val typ_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> typ
      val sexp_of_exp : exp -> Ppx_sexp_conv_lib.Sexp.t
      val sexp_of_typ : typ -> Ppx_sexp_conv_lib.Sexp.t
      type stmt =
        Types.stmt =
          Move of var * exp
        | Jmp of exp
        | Special of Trie.String.Suffix.key
        | While of exp * stmt list
        | If of exp * stmt list * stmt list
        | CpuExn of int
      val bin_stmt : stmt Core_kernel.Bin_prot.Type_class.t
      val bin_read_stmt : stmt Core_kernel.Bin_prot.Read.reader
      val __bin_read_stmt__ : (int -> stmt) Core_kernel.Bin_prot.Read.reader
      val bin_reader_stmt : stmt Core_kernel.Bin_prot.Type_class.reader
      val bin_size_stmt : stmt Core_kernel.Bin_prot.Size.sizer
      val bin_write_stmt : stmt Core_kernel.Bin_prot.Write.writer
      val bin_writer_stmt : stmt Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_stmt : Core_kernel.Bin_prot.Shape.t
      val compare_stmt : stmt -> stmt -> int
      val stmt_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> stmt
      val sexp_of_stmt : stmt -> Ppx_sexp_conv_lib.Sexp.t
      type t = stmt list
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val compare : t -> t -> int
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      type var_compare
      type vars = (var, Bap.Std.Bil.var_compare) Core_kernel.Set.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
      val pp_binop : binop Regular.Std.printer
      val pp_unop : unop Regular.Std.printer
      val pp_cast : cast Regular.Std.printer
      val string_of_binop : binop -> string
      val string_of_unop : unop -> string
      val string_of_cast : cast -> string
      module Infix :
        sig
          val ( := ) : var -> exp -> stmt
          val ( + ) : exp -> exp -> exp
          val ( - ) : exp -> exp -> exp
          val ( * ) : exp -> exp -> exp
          val ( / ) : exp -> exp -> exp
          val ( /$ ) : exp -> exp -> exp
          val ( mod ) : exp -> exp -> exp
          val ( %$ ) : exp -> exp -> exp
          val ( lsl ) : exp -> exp -> exp
          val ( lsr ) : exp -> exp -> exp
          val ( asr ) : exp -> exp -> exp
          val ( land ) : exp -> exp -> exp
          val ( lor ) : exp -> exp -> exp
          val ( lxor ) : exp -> exp -> exp
          val lnot : exp -> exp
          val ( = ) : exp -> exp -> exp
          val ( <> ) : exp -> exp -> exp
          val ( < ) : exp -> exp -> exp
          val ( > ) : exp -> exp -> exp
          val ( <= ) : exp -> exp -> exp
          val ( >= ) : exp -> exp -> exp
          val ( <$ ) : exp -> exp -> exp
          val ( >$ ) : exp -> exp -> exp
          val ( <=$ ) : exp -> exp -> exp
          val ( >=$ ) : exp -> exp -> exp
          val ( ^ ) : exp -> exp -> exp
        end
      val ( := ) : var -> exp -> stmt
      val ( + ) : exp -> exp -> exp
      val ( - ) : exp -> exp -> exp
      val ( * ) : exp -> exp -> exp
      val ( / ) : exp -> exp -> exp
      val ( /$ ) : exp -> exp -> exp
      val ( mod ) : exp -> exp -> exp
      val ( %$ ) : exp -> exp -> exp
      val ( lsl ) : exp -> exp -> exp
      val ( lsr ) : exp -> exp -> exp
      val ( asr ) : exp -> exp -> exp
      val ( land ) : exp -> exp -> exp
      val ( lor ) : exp -> exp -> exp
      val ( lxor ) : exp -> exp -> exp
      val lnot : exp -> exp
      val ( = ) : exp -> exp -> exp
      val ( <> ) : exp -> exp -> exp
      val ( < ) : exp -> exp -> exp
      val ( > ) : exp -> exp -> exp
      val ( <= ) : exp -> exp -> exp
      val ( >= ) : exp -> exp -> exp
      val ( <$ ) : exp -> exp -> exp
      val ( >$ ) : exp -> exp -> exp
      val ( <=$ ) : exp -> exp -> exp
      val ( >=$ ) : exp -> exp -> exp
      val ( ^ ) : exp -> exp -> exp
      val move : var -> exp -> stmt
      val jmp : exp -> stmt
      val special : string -> stmt
      val while_ : exp -> stmt list -> stmt
      val if_ : exp -> stmt list -> stmt list -> stmt
      val cpuexn : int -> stmt
      val unsigned : cast
      val signed : cast
      val high : cast
      val low : cast
      val plus : binop
      val minus : binop
      val times : binop
      val divide : binop
      val sdivide : binop
      val modulo : binop
      val smodulo : binop
      val lshift : binop
      val rshift : binop
      val arshift : binop
      val bit_and : binop
      val bit_or : binop
      val bit_xor : binop
      val eq : binop
      val neq : binop
      val lt : binop
      val le : binop
      val slt : binop
      val sle : binop
      val neg : unop
      val not : unop
      val load : mem:exp -> addr:exp -> Bap.Std.endian -> Bap.Std.size -> exp
      val store :
        mem:exp -> addr:exp -> exp -> Bap.Std.endian -> Bap.Std.size -> exp
      val binop : binop -> exp -> exp -> exp
      val unop : unop -> exp -> exp
      val var : var -> exp
      val int : Bap.Std.word -> exp
      val cast : cast -> int -> exp -> exp
      val let_ : var -> exp -> exp -> exp
      val unknown : string -> typ -> exp
      val ite : if_:exp -> then_:exp -> else_:exp -> exp
      val extract : hi:int -> lo:int -> exp -> exp
      val concat : exp -> exp -> exp
      val is_referenced : var -> stmt list -> bool
      val is_assigned : ?strict:bool -> var -> stmt list -> bool
      val prune_unreferenced :
        ?such_that:(var -> bool) ->
        ?physicals:bool -> ?virtuals:bool -> stmt list -> stmt list
      val normalize_negatives : stmt list -> stmt list
      val substitute : exp -> exp -> stmt list -> stmt list
      val substitute_var : var -> exp -> stmt list -> stmt list
      val free_vars : stmt list -> Bap.Std.Bil.vars
      val fold_consts : stmt list -> stmt list
      val fixpoint : (stmt list -> stmt list) -> stmt list -> stmt list
      val propagate_consts : stmt list -> stmt list
      val prune_dead_virtuals : stmt list -> stmt list
      module Apply :
        sig
          val binop : binop -> Bap.Std.word -> Bap.Std.word -> Bap.Std.word
          val unop : unop -> Bap.Std.word -> Bap.Std.word
          val cast : cast -> int -> Bap.Std.word -> Bap.Std.word
        end
      type result
      class type storage =
        object ('a)
          method load : Bap.Std.addr -> Bap.Std.word option
          method save : Bap.Std.addr -> Bap.Std.word -> 'a
        end
      module Storage : sig class linear : storage class sparse : storage end
      type value = Imm of Bap.Std.word | Mem of Bap.Std.Bil.storage | Bot
      module Result :
        sig
          type id
          type t = Bap.Std.Bil.result
          type 'a r = (Bap.Std.Bil.result, 'a) Monads.Std.Monad.State.t
          type 'a u = (unit, 'a) Monads.Std.Monad.State.t
          val undefined : Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
          val storage :
            Bap.Std.Bil.storage ->
            Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
          val word :
            Bap.Std.word -> Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
          val id : Bap.Std.Bil.Result.t -> Bap.Std.Bil.Result.id
          val value : Bap.Std.Bil.Result.t -> Bap.Std.Bil.value
          module Id :
            sig
              type t = id
              val bin_t : t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Formatter.t -> t -> unit
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
              module Map :
                sig
                  module Key :
                    sig
                      type t = id
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (id, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : id -> '-> 'a t
                      val of_alist :
                        (id * 'a) list ->
                        [ `Duplicate_key of id | `Ok of 'a t ]
                      val of_alist_or_error :
                        (id * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (id * 'a) list -> 'a t
                      val of_alist_multi : (id * 'a) list -> 'a list t
                      val of_alist_fold :
                        (id * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (id * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (id * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked : (id * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id * 'a) -> 'a t
                      val of_increasing_sequence :
                        (id * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of id | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (id, 'a) Addr.Table.hashtbl -> 'a t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:id ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:id -> data:'-> 'a t
                      val set : 'a t -> key:id -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:id -> data:'-> 'a list t
                      val remove_multi : 'a list t -> id -> 'a list t
                      val find_multi : 'a list t -> id -> 'a list
                      val change :
                        'a t -> id -> f:('a option -> 'a option) -> 'a t
                      val update : 'a t -> id -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> id -> 'a option
                      val find_exn : 'a t -> id -> 'a
                      val remove : 'a t -> id -> 'a t
                      val mem : 'a t -> id -> bool
                      val iter_keys : 'a t -> f:(id -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:id -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi : 'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:id -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:id -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> id list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (id * 'a) list
                      val validate :
                        name:(id -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (id, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (id * 'a) option
                      val min_elt_exn : 'a t -> id * 'a
                      val max_elt : 'a t -> (id * 'a) option
                      val max_elt_exn : 'a t -> id * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:id -> data:'-> bool) -> int
                      val split :
                        'a t -> id -> 'a t * (id * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:id Base__.Maybe_bound.t ->
                        upper_bound:id Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:id ->
                        max:id ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:id -> max:id -> (id * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> id -> (id * 'a) option
                      val nth : 'a t -> int -> (id * 'a) option
                      val nth_exn : 'a t -> int -> id * 'a
                      val rank : 'a t -> id -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:id ->
                        ?keys_less_or_equal_to:id ->
                        'a t -> (id * 'a) Base__.Sequence.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> id
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (id, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : id -> '-> 'a t
                  val of_alist :
                    (id * 'a) list -> [ `Duplicate_key of id | `Ok of 'a t ]
                  val of_alist_or_error :
                    (id * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (id * 'a) list -> 'a t
                  val of_alist_multi : (id * 'a) list -> 'a list t
                  val of_alist_fold :
                    (id * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (id * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (id * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (id * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> id * 'a) -> 'a t
                  val of_increasing_sequence :
                    (id * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of id | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn : (id, 'a) Addr.Table.hashtbl -> 'a t
                  val gen :
                    id Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:id -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:id -> data:'-> 'a t
                  val set : 'a t -> key:id -> data:'-> 'a t
                  val add_multi : 'a list t -> key:id -> data:'-> 'a list t
                  val remove_multi : 'a list t -> id -> 'a list t
                  val find_multi : 'a list t -> id -> 'a list
                  val change :
                    'a t -> id -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> id -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> id -> 'a option
                  val find_exn : 'a t -> id -> 'a
                  val remove : 'a t -> id -> 'a t
                  val mem : 'a t -> id -> bool
                  val iter_keys : 'a t -> f:(id -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:id -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:id ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:id ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri : 'a t -> f:(key:id -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:id -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:id -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:id -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> id list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (id * 'a) list
                  val validate :
                    name:(id -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:id ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (id, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (id * 'a) option
                  val min_elt_exn : 'a t -> id * 'a
                  val max_elt : 'a t -> (id * 'a) option
                  val max_elt_exn : 'a t -> id * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:id -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi : 'a t -> f:(key:id -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:id -> data:'-> bool) -> int
                  val split : 'a t -> id -> 'a t * (id * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:id Base__.Maybe_bound.t ->
                    upper_bound:id Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:id ->
                    max:id ->
                    init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:id -> max:id -> (id * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> id -> (id * 'a) option
                  val nth : 'a t -> int -> (id * 'a) option
                  val nth_exn : 'a t -> int -> id * 'a
                  val rank : 'a t -> id -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:id ->
                    ?keys_less_or_equal_to:id ->
                    'a t -> (id * 'a) Base__.Sequence.t
                  val obs :
                    id Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    id Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> id
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : id Bin_prot.Type_class.t
                               val bin_read_t : id Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> id)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 id Bin_prot.Type_class.reader
                               val bin_size_t : id Bin_prot.Size.sizer
                               val bin_write_t : id Bin_prot.Write.writer
                               val bin_writer_t :
                                 id Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state -> id -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = id
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (id, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (id, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(id -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> id -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(id -> bool) -> bool
                      val for_all : t -> f:(id -> bool) -> bool
                      val count : t -> f:(id -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(id -> 'sum) -> 'sum
                      val find : t -> f:(id -> bool) -> id option
                      val find_map : t -> f:(id -> 'a option) -> 'a option
                      val to_list : t -> id list
                      val to_array : t -> id array
                      val invariants : t -> bool
                      val mem : t -> id -> bool
                      val add : t -> id -> t
                      val remove : t -> id -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           id ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(id -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of id * id | `Left of id | `Right of id ] ->
                           unit) ->
                        unit
                      val filter : t -> f:(id -> bool) -> t
                      val partition_tf : t -> f:(id -> bool) -> t * t
                      val elements : t -> id list
                      val min_elt : t -> id option
                      val min_elt_exn : t -> id
                      val max_elt : t -> id option
                      val max_elt_exn : t -> id
                      val choose : t -> id option
                      val choose_exn : t -> id
                      val split : t -> id -> t * id option * t
                      val group_by : t -> equiv:(id -> id -> bool) -> t list
                      val find_exn : t -> f:(id -> bool) -> id
                      val find_index : t -> int -> id option
                      val nth : t -> int -> id option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id ->
                        t ->
                        t ->
                        (id, id) Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(id -> 'data) ->
                        (id, 'data, comparator_witness) Core_kernel__.Map.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : id -> t
                      val union_list : t list -> t
                      val of_list : id list -> t
                      val of_array : id array -> t
                      val of_sorted_array : id array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : id array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id) -> t
                      val stable_dedup_list : id list -> id list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> id) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> id option) -> t
                      val of_tree : t -> t
                      val of_hash_set : id Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys : (id, 'a) Addr.Table.hashtbl -> t
                      val of_map_keys :
                        (id, 'a, comparator_witness) Core_kernel__.Map.t -> t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> id
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (id, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (id, comparator_witness) Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(id -> unit) -> unit
                  val fold :
                    t -> init:'accum -> f:('accum -> id -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(id -> bool) -> bool
                  val for_all : t -> f:(id -> bool) -> bool
                  val count : t -> f:(id -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(id -> 'sum) -> 'sum
                  val find : t -> f:(id -> bool) -> id option
                  val find_map : t -> f:(id -> 'a option) -> 'a option
                  val to_list : t -> id list
                  val to_array : t -> id array
                  val invariants : t -> bool
                  val mem : t -> id -> bool
                  val add : t -> id -> t
                  val remove : t -> id -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       id -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(id -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of id * id | `Left of id | `Right of id ] ->
                       unit) ->
                    unit
                  val filter : t -> f:(id -> bool) -> t
                  val partition_tf : t -> f:(id -> bool) -> t * t
                  val elements : t -> id list
                  val min_elt : t -> id option
                  val min_elt_exn : t -> id
                  val max_elt : t -> id option
                  val max_elt_exn : t -> id
                  val choose : t -> id option
                  val choose_exn : t -> id
                  val split : t -> id -> t * id option * t
                  val group_by : t -> equiv:(id -> id -> bool) -> t list
                  val find_exn : t -> f:(id -> bool) -> id
                  val find_index : t -> int -> id option
                  val nth : t -> int -> id option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:id ->
                    ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:id ->
                    ?less_or_equal_to:id ->
                    t ->
                    t ->
                    (id, id) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(id -> 'data) ->
                    (id, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    id Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    id Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : id -> t
                  val union_list : t list -> t
                  val of_list : id list -> t
                  val of_array : id array -> t
                  val of_sorted_array : id array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : id array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> id) -> t
                  val stable_dedup_list : id list -> id list
                  val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> id option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : id Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (id, 'a) Addr.Table.hashtbl -> t
                  val of_map_keys :
                    (id, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    id Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> id
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : id Bin_prot.Type_class.t
                               val bin_read_t : id Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> id)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 id Bin_prot.Type_class.reader
                               val bin_size_t : id Bin_prot.Size.sizer
                               val bin_write_t : id Bin_prot.Write.writer
                               val bin_writer_t :
                                 id Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state -> id -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                t -> Ppx_hash_lib.Std.Hash.state
              val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : t Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Addr.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = id
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> id -> Core_kernel__.Import.bool
                  val lookup : 'a t -> id -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> id -> 'a
                  val enqueue :
                    'a t -> id -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> id -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> id -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (id * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> id Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (id * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> id * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> id -> Core_kernel__.Import.unit
                  val replace : 'a t -> id -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> id -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:id -> data:'-> 'b) -> 'b
                end
              type info =
                  Trie.String.Suffix.key *
                  [ `Ver of Trie.String.Suffix.key ] *
                  Trie.String.Suffix.key option
              val version : Trie.String.Suffix.key
              val size_in_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> int
              val of_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
              val to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
              val blit_to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Regular.Std.bytes -> t -> int -> unit
              val of_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
              val to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
              val blit_to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.bigstring -> t -> int -> unit
              module Io :
                sig
                  val read :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t
                  val load :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.In_channel.t -> t
                  val load_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    ?rev:bool -> Core_kernel.In_channel.t -> t list
                  val scan :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.In_channel.t -> unit -> t option
                  val write :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t -> unit
                  val save :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Out_channel.t -> t -> unit
                  val save_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Out_channel.t -> t list -> unit
                  val dump :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Out_channel.t -> (unit -> t option) -> unit
                  val show :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key -> t -> unit
                  val print :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Format.formatter -> t -> unit
                end
              module Cache :
                sig
                  val load : Regular.Std.digest -> t option
                  val save : Regular.Std.digest -> t -> unit
                end
              val add_reader :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader -> unit
              val add_writer :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer -> unit
              val available_readers : unit -> info list
              val default_reader : unit -> info
              val set_default_reader :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val available_writers : unit -> info list
              val default_writer : unit -> info
              val set_default_writer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val default_printer : unit -> info option
              val set_default_printer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_printer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val find_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader option
              val find_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer option
              val zero : Bap.Std.Bil.Result.t
              val succ : Bap.Std.Bil.Result.t -> Bap.Std.Bil.Result.t
            end
          module Value :
            sig
              type t = value
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Formatter.t -> t -> unit
            end
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
        end
      module Trie :
        sig
          type normalized_bil
          val normalize :
            ?subst:(exp * exp) list ->
            stmt list -> Bap.Std.Bil.Trie.normalized_bil
          module Normalized :
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              type key = normalized_bil
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          type 'a t
          val bin_t :
            'Core_kernel.Bin_prot.Type_class.t ->
            'a t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t :
            'Core_kernel.Bin_prot.Read.reader ->
            'a t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ :
            'Core_kernel.Bin_prot.Read.reader ->
            (int -> 'a t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t :
            'Core_kernel.Bin_prot.Type_class.reader ->
            'a t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t :
            'Core_kernel.Bin_prot.Size.sizer ->
            'a t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t :
            'Core_kernel.Bin_prot.Write.writer ->
            'a t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t :
            'Core_kernel.Bin_prot.Type_class.writer ->
            'a t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t :
            Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          type key = stmt list
          val create : unit -> 'a t
          val add : 'a t -> key:key -> data:'-> unit
          val change : 'a t -> key -> ('a option -> 'a option) -> unit
          val find : 'a t -> key -> 'a option
          val walk :
            'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
          val remove : 'a t -> key -> unit
          val longest_match : 'a t -> key -> (int * 'a) option
          val length : 'a t -> int
          val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
        end
      type pass
      val register_pass :
        ?desc:string ->
        string -> (Bap.Std.Bil.t -> Bap.Std.Bil.t) -> Bap.Std.Bil.pass
      val select_passes : Bap.Std.Bil.pass list -> unit
      val passes : unit -> Bap.Std.Bil.pass list
      module Pass :
        sig
          val name : Bap.Std.Bil.pass -> string
          val to_string : pass -> string
          val str : unit -> pass -> string
          val pps : unit -> pass -> string
          val ppo : Core_kernel.Out_channel.t -> pass -> unit
          val pp_seq : Format.formatter -> pass Seq.t -> unit
          val pp : Base__.Formatter.t -> pass -> unit
        end
    end
  type typ = Bap.Std.Bil.typ
  val bin_typ : typ Core_kernel.Bin_prot.Type_class.t
  val bin_read_typ : typ Core_kernel.Bin_prot.Read.reader
  val __bin_read_typ__ : (int -> typ) Core_kernel.Bin_prot.Read.reader
  val bin_reader_typ : typ Core_kernel.Bin_prot.Type_class.reader
  val bin_size_typ : typ Core_kernel.Bin_prot.Size.sizer
  val bin_write_typ : typ Core_kernel.Bin_prot.Write.writer
  val bin_writer_typ : typ Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_typ : Core_kernel.Bin_prot.Shape.t
  val compare_typ : typ -> typ -> int
  val typ_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> typ
  val sexp_of_typ : typ -> Ppx_sexp_conv_lib.Sexp.t
  type var = Bap.Std.Bil.var
  val bin_var : var Core_kernel.Bin_prot.Type_class.t
  val bin_read_var : var Core_kernel.Bin_prot.Read.reader
  val __bin_read_var__ : (int -> var) Core_kernel.Bin_prot.Read.reader
  val bin_reader_var : var Core_kernel.Bin_prot.Type_class.reader
  val bin_size_var : var Core_kernel.Bin_prot.Size.sizer
  val bin_write_var : var Core_kernel.Bin_prot.Write.writer
  val bin_writer_var : var Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_var : Core_kernel.Bin_prot.Shape.t
  val compare_var : var -> var -> int
  val var_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> var
  val sexp_of_var : var -> Ppx_sexp_conv_lib.Sexp.t
  type bil = Bap.Std.Bil.t
  val bin_bil : bil Core_kernel.Bin_prot.Type_class.t
  val bin_read_bil : bil Core_kernel.Bin_prot.Read.reader
  val __bin_read_bil__ : (int -> bil) Core_kernel.Bin_prot.Read.reader
  val bin_reader_bil : bil Core_kernel.Bin_prot.Type_class.reader
  val bin_size_bil : bil Core_kernel.Bin_prot.Size.sizer
  val bin_write_bil : bil Core_kernel.Bin_prot.Write.writer
  val bin_writer_bil : bil Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_bil : Core_kernel.Bin_prot.Shape.t
  val compare_bil : bil -> bil -> int
  val bil_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> bil
  val sexp_of_bil : bil -> Ppx_sexp_conv_lib.Sexp.t
  type binop = Bap.Std.Bil.binop
  val bin_binop : binop Core_kernel.Bin_prot.Type_class.t
  val bin_read_binop : binop Core_kernel.Bin_prot.Read.reader
  val __bin_read_binop__ : (int -> binop) Core_kernel.Bin_prot.Read.reader
  val bin_reader_binop : binop Core_kernel.Bin_prot.Type_class.reader
  val bin_size_binop : binop Core_kernel.Bin_prot.Size.sizer
  val bin_write_binop : binop Core_kernel.Bin_prot.Write.writer
  val bin_writer_binop : binop Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_binop : Core_kernel.Bin_prot.Shape.t
  val compare_binop : binop -> binop -> int
  val binop_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> binop
  val sexp_of_binop : binop -> Ppx_sexp_conv_lib.Sexp.t
  type cast = Bap.Std.Bil.cast
  val bin_cast : cast Core_kernel.Bin_prot.Type_class.t
  val bin_read_cast : cast Core_kernel.Bin_prot.Read.reader
  val __bin_read_cast__ : (int -> cast) Core_kernel.Bin_prot.Read.reader
  val bin_reader_cast : cast Core_kernel.Bin_prot.Type_class.reader
  val bin_size_cast : cast Core_kernel.Bin_prot.Size.sizer
  val bin_write_cast : cast Core_kernel.Bin_prot.Write.writer
  val bin_writer_cast : cast Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_cast : Core_kernel.Bin_prot.Shape.t
  val compare_cast : cast -> cast -> int
  val cast_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cast
  val sexp_of_cast : cast -> Ppx_sexp_conv_lib.Sexp.t
  type exp = Bap.Std.Bil.exp
  val bin_exp : exp Core_kernel.Bin_prot.Type_class.t
  val bin_read_exp : exp Core_kernel.Bin_prot.Read.reader
  val __bin_read_exp__ : (int -> exp) Core_kernel.Bin_prot.Read.reader
  val bin_reader_exp : exp Core_kernel.Bin_prot.Type_class.reader
  val bin_size_exp : exp Core_kernel.Bin_prot.Size.sizer
  val bin_write_exp : exp Core_kernel.Bin_prot.Write.writer
  val bin_writer_exp : exp Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_exp : Core_kernel.Bin_prot.Shape.t
  val compare_exp : exp -> exp -> int
  val exp_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> exp
  val sexp_of_exp : exp -> Ppx_sexp_conv_lib.Sexp.t
  type stmt = Bap.Std.Bil.stmt
  val bin_stmt : stmt Core_kernel.Bin_prot.Type_class.t
  val bin_read_stmt : stmt Core_kernel.Bin_prot.Read.reader
  val __bin_read_stmt__ : (int -> stmt) Core_kernel.Bin_prot.Read.reader
  val bin_reader_stmt : stmt Core_kernel.Bin_prot.Type_class.reader
  val bin_size_stmt : stmt Core_kernel.Bin_prot.Size.sizer
  val bin_write_stmt : stmt Core_kernel.Bin_prot.Write.writer
  val bin_writer_stmt : stmt Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_stmt : Core_kernel.Bin_prot.Shape.t
  val compare_stmt : stmt -> stmt -> int
  val stmt_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> stmt
  val sexp_of_stmt : stmt -> Ppx_sexp_conv_lib.Sexp.t
  type unop = Bap.Std.Bil.unop
  val bin_unop : unop Core_kernel.Bin_prot.Type_class.t
  val bin_read_unop : unop Core_kernel.Bin_prot.Read.reader
  val __bin_read_unop__ : (int -> unop) Core_kernel.Bin_prot.Read.reader
  val bin_reader_unop : unop Core_kernel.Bin_prot.Type_class.reader
  val bin_size_unop : unop Core_kernel.Bin_prot.Size.sizer
  val bin_write_unop : unop Core_kernel.Bin_prot.Write.writer
  val bin_writer_unop : unop Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_unop : Core_kernel.Bin_prot.Shape.t
  val compare_unop : unop -> unop -> int
  val unop_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> unop
  val sexp_of_unop : unop -> Ppx_sexp_conv_lib.Sexp.t
  module Type :
    sig
      type t =
        Bap.Std.Bil.typ =
          Imm of int
        | Mem of Bap.Std.addr_size * Bap.Std.size
      module Variants :
        sig
          val imm : (int -> t) Variantslib.Variant.t
          val mem : (addr_size -> size -> t) Variantslib.Variant.t
          val fold :
            init:'acc__ ->
            imm:('acc__ -> (int -> t) Variantslib.Variant.t -> 'acc__) ->
            mem:('acc__ ->
                 (addr_size -> size -> t) Variantslib.Variant.t -> 'acc__) ->
            'acc__
          val iter :
            imm:((int -> t) Variantslib.Variant.t -> unit) ->
            mem:((addr_size -> size -> t) Variantslib.Variant.t -> unit) ->
            unit
          val map :
            t ->
            imm:((int -> t) Variantslib.Variant.t -> int -> 'result__) ->
            mem:((addr_size -> size -> t) Variantslib.Variant.t ->
                 addr_size -> size -> 'result__) ->
            'result__
          val to_rank : t -> int
          val to_name : t -> Trie.String.Suffix.key
          val descriptions : (Trie.String.Suffix.key * int) list
        end
      type error
      val bin_error : error Core_kernel.Bin_prot.Type_class.t
      val bin_read_error : error Core_kernel.Bin_prot.Read.reader
      val __bin_read_error__ :
        (int -> error) Core_kernel.Bin_prot.Read.reader
      val bin_reader_error : error Core_kernel.Bin_prot.Type_class.reader
      val bin_size_error : error Core_kernel.Bin_prot.Size.sizer
      val bin_write_error : error Core_kernel.Bin_prot.Write.writer
      val bin_writer_error : error Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_error : Core_kernel.Bin_prot.Shape.t
      val compare_error : error -> error -> int
      val error_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> error
      val sexp_of_error : error -> Ppx_sexp_conv_lib.Sexp.t
      val imm : int -> Bap.Std.Type.t
      val mem : Bap.Std.addr_size -> Bap.Std.size -> Bap.Std.Type.t
      val infer :
        Bap.Std.exp ->
        (Bap.Std.Type.t, Bap.Std.Type.error) Core_kernel.Result.t
      val infer_exn : Bap.Std.exp -> Bap.Std.Type.t
      val check :
        Bap.Std.bil -> (unit, Bap.Std.Type.error) Core_kernel.Result.t
      module Error :
        sig
          type t = Bap.Std.Type.error
          exception T of Bap.Std.Type.Error.t
          val bad_mem : Bap.Std.Type.Error.t
          val bad_imm : Bap.Std.Type.Error.t
          val bad_cast : Bap.Std.Type.Error.t
          val bad_type :
            exp:Bap.Std.typ -> got:Bap.Std.typ -> Bap.Std.Type.Error.t
          val expect_mem : unit -> 'a
          val expect_imm : unit -> 'a
          val wrong_cast : unit -> 'a
          val expect : Bap.Std.typ -> got:Bap.Std.typ -> 'a
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.Type.error
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_increasing_sequence :
                    (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (Key.t, 'a) Addr.Table.hashtbl -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:Key.t ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
                  val set : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val find_multi : 'a list t -> Key.t -> 'a list
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Key.t
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Addr.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (Elt.t, 'a) Addr.Table.hashtbl -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Addr.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Addr.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.Bil.typ
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Error.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Error.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Error.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Error.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Error.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  val bool_t : Bap.Std.typ
  val reg8_t : Bap.Std.typ
  val reg16_t : Bap.Std.typ
  val reg32_t : Bap.Std.typ
  val reg64_t : Bap.Std.typ
  val reg128_t : Bap.Std.typ
  val reg256_t : Bap.Std.typ
  val mem32_t : Bap.Std.size -> Bap.Std.typ
  val mem64_t : Bap.Std.size -> Bap.Std.typ
  module Var :
    sig
      type t = Bap.Std.var
      val create :
        ?is_virtual:bool ->
        ?fresh:bool -> string -> Bap.Std.typ -> Bap.Std.Var.t
      val name : Bap.Std.Var.t -> string
      val typ : Bap.Std.Var.t -> Bap.Std.typ
      val is_physical : Bap.Std.Var.t -> bool
      val is_virtual : Bap.Std.Var.t -> bool
      val with_index : Bap.Std.Var.t -> int -> Bap.Std.Var.t
      val index : Bap.Std.Var.t -> int
      val base : Bap.Std.Var.t -> Bap.Std.Var.t
      val same : Bap.Std.Var.t -> Bap.Std.Var.t -> bool
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness = Bil.var_compare
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.var
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = Bil.var_compare
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Type.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Type.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Bil.var_compare
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Type.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Type.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Type.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Context :
    sig
      class t :
        object ('a)
          method bindings : (Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
          method lookup : Bap.Std.var -> Bap.Std.Bil.result option
          method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
        end
    end
  module Type_error :
    sig
      type t = Type.Error.t
      exception T of t
      val bad_mem : t
      val bad_imm : t
      val bad_cast : t
      val bad_type : exp:typ -> got:typ -> t
      val expect_mem : unit -> 'a
      val expect_imm : unit -> 'a
      val wrong_cast : unit -> 'a
      val expect : typ -> got:typ -> 'a
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Type.Error.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Var.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Var.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Var.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Var.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Var.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  type type_error = Bap.Std.Type_error.t
  val bin_type_error : type_error Core_kernel.Bin_prot.Type_class.t
  val bin_read_type_error : type_error Core_kernel.Bin_prot.Read.reader
  val __bin_read_type_error__ :
    (int -> type_error) Core_kernel.Bin_prot.Read.reader
  val bin_reader_type_error :
    type_error Core_kernel.Bin_prot.Type_class.reader
  val bin_size_type_error : type_error Core_kernel.Bin_prot.Size.sizer
  val bin_write_type_error : type_error Core_kernel.Bin_prot.Write.writer
  val bin_writer_type_error :
    type_error Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_type_error : Core_kernel.Bin_prot.Shape.t
  val compare_type_error : type_error -> type_error -> int
  val type_error_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> type_error
  val sexp_of_type_error : type_error -> Ppx_sexp_conv_lib.Sexp.t
  module Eval :
    sig
      module T1 :
        functor (M : Core_kernel.T1->
          sig
            type 'a m = 'M.t
            class type ['r] semantics =
              object
                method eval_binop :
                  Bap.Std.binop ->
                  Bap.Std.exp -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                method eval_cast :
                  Bap.Std.cast -> int -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                method eval_concat :
                  Bap.Std.exp -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                method eval_exp : Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                method eval_extract :
                  int -> int -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                method eval_int : Bap.Std.word -> 'Bap.Std.Eval.T1.m
                method eval_ite :
                  cond:Bap.Std.exp ->
                  yes:Bap.Std.exp -> no:Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                method eval_let :
                  Bap.Std.var ->
                  Bap.Std.exp -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                method eval_load :
                  mem:Bap.Std.exp ->
                  addr:Bap.Std.exp ->
                  Bap.Std.endian -> Bap.Std.size -> 'Bap.Std.Eval.T1.m
                method eval_store :
                  mem:Bap.Std.exp ->
                  addr:Bap.Std.exp ->
                  Bap.Std.exp ->
                  Bap.Std.endian -> Bap.Std.size -> 'Bap.Std.Eval.T1.m
                method eval_unknown :
                  string -> Bap.Std.typ -> 'Bap.Std.Eval.T1.m
                method eval_unop :
                  Bap.Std.unop -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                method eval_var : Bap.Std.var -> 'Bap.Std.Eval.T1.m
              end
            class type virtual ['r, 's] domain =
              object
                method private virtual storage_of_value :
                  '-> 's option Bap.Std.Eval.T1.m
                method private virtual undefined : 'Bap.Std.Eval.T1.m
                method private virtual value_of_word :
                  Bap.Std.word -> 'Bap.Std.Eval.T1.m
                method private virtual word_of_value :
                  '-> Bap.Std.word option Bap.Std.Eval.T1.m
              end
            class type virtual ['r, 's] eff =
              object
                method virtual load :
                  '-> Bap.Std.addr -> 'Bap.Std.Eval.T1.m
                method virtual lookup : Bap.Std.var -> 'Bap.Std.Eval.T1.m
                method virtual store :
                  '-> Bap.Std.addr -> Bap.Std.word -> 'Bap.Std.Eval.T1.m
                method virtual update :
                  Bap.Std.var -> '-> unit Bap.Std.Eval.T1.m
              end
          end
      module T2 :
        functor (M : Core_kernel.T2->
          sig
            type ('a, 'e) m = ('a, 'e) M.t
            class type ['a, 'r] semantics =
              object
                method eval_binop :
                  Bap.Std.binop ->
                  Bap.Std.exp -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_cast :
                  Bap.Std.cast ->
                  int -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_concat :
                  Bap.Std.exp -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_exp : Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_extract :
                  int -> int -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_int : Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_ite :
                  cond:Bap.Std.exp ->
                  yes:Bap.Std.exp ->
                  no:Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_let :
                  Bap.Std.var ->
                  Bap.Std.exp -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_load :
                  mem:Bap.Std.exp ->
                  addr:Bap.Std.exp ->
                  Bap.Std.endian ->
                  Bap.Std.size -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_store :
                  mem:Bap.Std.exp ->
                  addr:Bap.Std.exp ->
                  Bap.Std.exp ->
                  Bap.Std.endian ->
                  Bap.Std.size -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_unknown :
                  string -> Bap.Std.typ -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_unop :
                  Bap.Std.unop -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                method eval_var : Bap.Std.var -> ('r, 'a) Bap.Std.Eval.T2.m
              end
            class type virtual ['a, 'r, 's] domain =
              object
                method private virtual storage_of_value :
                  '-> ('s option, 'a) Bap.Std.Eval.T2.m
                method private virtual undefined : ('r, 'a) Bap.Std.Eval.T2.m
                method private virtual value_of_word :
                  Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
                method private virtual word_of_value :
                  '-> (Bap.Std.word option, 'a) Bap.Std.Eval.T2.m
              end
            class type virtual ['a, 'r, 's] eff =
              object
                method virtual load :
                  '-> Bap.Std.addr -> ('r, 'a) Bap.Std.Eval.T2.m
                method virtual lookup :
                  Bap.Std.var -> ('r, 'a) Bap.Std.Eval.T2.m
                method virtual store :
                  '->
                  Bap.Std.addr -> Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
                method virtual update :
                  Bap.Std.var -> '-> (unit, 'a) Bap.Std.Eval.T2.m
              end
          end
      module type S =
        sig
          type 'a m
          module M : sig type 'a t = 'a m end
          class type ['r] semantics = ['r] T1(M).semantics
          class type virtual ['r, 's] domain = ['r, 's] T1(M).domain
          class type virtual ['r, 's] eff = ['r, 's] T1(M).eff
          class virtual ['r, 's] t :
            object
              method division_by_zero : unit -> 'Bap.Std.Eval.S.m
              method eval_binop : binop -> exp -> exp -> 'M.t
              method eval_cast : cast -> int -> exp -> 'M.t
              method eval_concat : exp -> exp -> 'M.t
              method eval_exp : exp -> 'M.t
              method eval_extract : int -> int -> exp -> 'M.t
              method eval_int : word -> 'M.t
              method eval_ite : cond:exp -> yes:exp -> no:exp -> 'M.t
              method eval_let : var -> exp -> exp -> 'M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> 'M.t
              method eval_store :
                mem:exp -> addr:exp -> exp -> endian -> size -> 'M.t
              method eval_unknown : Trie.String.Suffix.key -> typ -> 'M.t
              method eval_unop : unop -> exp -> 'M.t
              method eval_var : var -> 'M.t
              method virtual load : '-> addr -> 'M.t
              method virtual lookup : var -> 'M.t
              method private virtual storage_of_value : '-> 's option M.t
              method virtual store : '-> addr -> word -> 'M.t
              method type_error : Bap.Std.type_error -> 'Bap.Std.Eval.S.m
              method private virtual undefined : 'M.t
              method virtual update : var -> '-> unit M.t
              method private virtual value_of_word : word -> 'M.t
              method private virtual word_of_value : '-> word option M.t
            end
        end
      module type S2 =
        sig
          type ('a, 'e) m
          module M : sig type ('a, 'e) t = ('a, 'e) m end
          class type ['a, 'r] semantics = ['a, 'r] T2(M).semantics
          class type virtual ['a, 'r, 's] domain = ['a, 'r, 's] T2(M).domain
          class type virtual ['a, 'r, 's] eff = ['a, 'r, 's] T2(M).eff
          class virtual ['a, 'r, 's] t :
            object
              method division_by_zero : unit -> ('r, 'a) Bap.Std.Eval.S2.m
              method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
              method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
              method eval_concat : exp -> exp -> ('r, 'a) M.t
              method eval_exp : exp -> ('r, 'a) M.t
              method eval_extract : int -> int -> exp -> ('r, 'a) M.t
              method eval_int : word -> ('r, 'a) M.t
              method eval_ite : cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
              method eval_let : var -> exp -> exp -> ('r, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
              method eval_store :
                mem:exp -> addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
              method eval_unop : unop -> exp -> ('r, 'a) M.t
              method eval_var : var -> ('r, 'a) M.t
              method virtual load : '-> addr -> ('r, 'a) M.t
              method virtual lookup : var -> ('r, 'a) M.t
              method private virtual storage_of_value :
                '-> ('s option, 'a) M.t
              method virtual store : '-> addr -> word -> ('r, 'a) M.t
              method type_error :
                Bap.Std.type_error -> ('r, 'a) Bap.Std.Eval.S2.m
              method private virtual undefined : ('r, 'a) M.t
              method virtual update : var -> '-> (unit, 'a) M.t
              method private virtual value_of_word : word -> ('r, 'a) M.t
              method private virtual word_of_value :
                '-> (word option, 'a) M.t
            end
        end
      module Make2 :
        functor (M : Monads.Std.Monad.S2->
          sig
            class type ['a, 'r] semantics = ['a, 'r] T2(M).semantics
            class type virtual ['a, 'r, 's] domain =
              ['a, 'r, 's] T2(M).domain
            class type virtual ['a, 'r, 's] eff = ['a, 'r, 's] T2(M).eff
            class virtual ['a, 'r, 's] t :
              object
                method division_by_zero : unit -> ('r, 'a) M.t
                method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                method eval_concat : exp -> exp -> ('r, 'a) M.t
                method eval_exp : exp -> ('r, 'a) M.t
                method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                method eval_int : word -> ('r, 'a) M.t
                method eval_ite :
                  cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                method eval_load :
                  mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                method eval_store :
                  mem:exp ->
                  addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                method eval_unknown :
                  Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                method eval_unop : unop -> exp -> ('r, 'a) M.t
                method eval_var : var -> ('r, 'a) M.t
                method virtual load : '-> addr -> ('r, 'a) M.t
                method virtual lookup : var -> ('r, 'a) M.t
                method private virtual storage_of_value :
                  '-> ('s option, 'a) M.t
                method virtual store : '-> addr -> word -> ('r, 'a) M.t
                method type_error : type_error -> ('r, 'a) M.t
                method private virtual undefined : ('r, 'a) M.t
                method virtual update : var -> '-> (unit, 'a) M.t
                method private virtual value_of_word : word -> ('r, 'a) M.t
                method private virtual word_of_value :
                  '-> (word option, 'a) M.t
              end
          end
      module Make :
        functor (M : Monads.Std.Monad.S->
          sig
            class type ['r] semantics = ['r] T1(M).semantics
            class type virtual ['r, 's] domain = ['r, 's] T1(M).domain
            class type virtual ['r, 's] eff = ['r, 's] T1(M).eff
            class virtual ['r, 's] t :
              object
                method division_by_zero : unit -> 'M.t
                method eval_binop : binop -> exp -> exp -> 'M.t
                method eval_cast : cast -> int -> exp -> 'M.t
                method eval_concat : exp -> exp -> 'M.t
                method eval_exp : exp -> 'M.t
                method eval_extract : int -> int -> exp -> 'M.t
                method eval_int : word -> 'M.t
                method eval_ite : cond:exp -> yes:exp -> no:exp -> 'M.t
                method eval_let : var -> exp -> exp -> 'M.t
                method eval_load :
                  mem:exp -> addr:exp -> endian -> size -> 'M.t
                method eval_store :
                  mem:exp -> addr:exp -> exp -> endian -> size -> 'M.t
                method eval_unknown : Trie.String.Suffix.key -> typ -> 'M.t
                method eval_unop : unop -> exp -> 'M.t
                method eval_var : var -> 'M.t
                method virtual load : '-> addr -> 'M.t
                method virtual lookup : var -> 'M.t
                method private virtual storage_of_value : '-> 's option M.t
                method virtual store : '-> addr -> word -> 'M.t
                method type_error : type_error -> 'M.t
                method private virtual undefined : 'M.t
                method virtual update : var -> '-> unit M.t
                method private virtual value_of_word : word -> 'M.t
                method private virtual word_of_value : '-> word option M.t
              end
          end
    end
  module Expi :
    sig
      class context :
        object ('a)
          method bindings : (Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
          method create_storage :
            Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
          method create_undefined : 'a * Bap.Std.Bil.result
          method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
          method lookup : Bap.Std.var -> Bap.Std.Bil.result option
          method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
        end
      module type S =
        sig
          type ('a, 'e) state
          type 'a u = (unit, 'a) Bap.Std.Expi.S.state
          type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Expi.S.state
          module M : sig type ('a, 'e) t = ('a, 'e) state end
          module Eval :
            sig
              class type ['a, 'r] semantics = ['a, 'r] Eval.T2(M).semantics
              class type virtual ['a, 'r, 's] domain =
                ['a, 'r, 's] Eval.T2(M).domain
              class type virtual ['a, 'r, 's] eff =
                ['a, 'r, 's] Eval.T2(M).eff
              class virtual ['a, 'r, 's] t :
                object
                  method division_by_zero : unit -> ('r, 'a) state
                  method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                  method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                  method eval_concat : exp -> exp -> ('r, 'a) M.t
                  method eval_exp : exp -> ('r, 'a) M.t
                  method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                  method eval_int : word -> ('r, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                  method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                  method eval_load :
                    mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                  method eval_unop : unop -> exp -> ('r, 'a) M.t
                  method eval_var : var -> ('r, 'a) M.t
                  method virtual load : '-> addr -> ('r, 'a) M.t
                  method virtual lookup : var -> ('r, 'a) M.t
                  method private virtual storage_of_value :
                    '-> ('s option, 'a) M.t
                  method virtual store : '-> addr -> word -> ('r, 'a) M.t
                  method type_error : type_error -> ('r, 'a) state
                  method private virtual undefined : ('r, 'a) M.t
                  method virtual update : var -> '-> (unit, 'a) M.t
                  method private virtual value_of_word : word -> ('r, 'a) M.t
                  method private virtual word_of_value :
                    '-> (word option, 'a) M.t
                end
            end
          class ['a] t :
            object
              constraint 'a = #Bap.Std.Expi.context
              method division_by_zero : unit -> 'Bap.Std.Expi.S.r
              method empty : Bap.Std.Bil.storage
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method load :
                Bap.Std.Bil.storage -> Bap.Std.addr -> 'Bap.Std.Expi.S.r
              method lookup : Bap.Std.var -> 'Bap.Std.Expi.S.r
              method store :
                Bap.Std.Bil.storage ->
                Bap.Std.addr -> Bap.Std.word -> 'Bap.Std.Expi.S.r
              method type_error : Bap.Std.type_error -> 'Bap.Std.Expi.S.r
              method undefined_addr : Bap.Std.addr -> 'Bap.Std.Expi.S.r
              method undefined_var : Bap.Std.var -> 'Bap.Std.Expi.S.r
              method update :
                Bap.Std.var -> Bap.Std.Bil.result -> 'Bap.Std.Expi.S.u
            end
        end
      module Make :
        functor (M : Monads.Std.Monad.State.S2->
          sig
            type ('a, 'e) state = ('a, 'e) M.t
            type 'a u = (unit, 'a) state
            type 'a r = (Bil.result, 'a) state
            module M : sig type ('a, 'e) t = ('a, 'e) state end
            module Eval :
              sig
                class type ['a, 'r] semantics = ['a, 'r] Eval.T2(M).semantics
                class type virtual ['a, 'r, 's] domain =
                  ['a, 'r, 's] Eval.T2(M).domain
                class type virtual ['a, 'r, 's] eff =
                  ['a, 'r, 's] Eval.T2(M).eff
                class virtual ['a, 'r, 's] t :
                  object
                    method division_by_zero : unit -> ('r, 'a) state
                    method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                    method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                    method eval_concat : exp -> exp -> ('r, 'a) M.t
                    method eval_exp : exp -> ('r, 'a) M.t
                    method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                    method eval_int : word -> ('r, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                    method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                    method eval_load :
                      mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                    method eval_store :
                      mem:exp ->
                      addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                    method eval_unop : unop -> exp -> ('r, 'a) M.t
                    method eval_var : var -> ('r, 'a) M.t
                    method virtual load : '-> addr -> ('r, 'a) M.t
                    method virtual lookup : var -> ('r, 'a) M.t
                    method private virtual storage_of_value :
                      '-> ('s option, 'a) M.t
                    method virtual store : '-> addr -> word -> ('r, 'a) M.t
                    method type_error : type_error -> ('r, 'a) state
                    method private virtual undefined : ('r, 'a) M.t
                    method virtual update : var -> '-> (unit, 'a) M.t
                    method private virtual value_of_word :
                      word -> ('r, 'a) M.t
                    method private virtual word_of_value :
                      '-> (word option, 'a) M.t
                  end
              end
            class ['a] t :
              object
                constraint 'a = #context
                method division_by_zero : unit -> 'a r
                method empty : Bil.storage
                method eval_binop :
                  binop -> exp -> exp -> (Bil.result, 'a) M.t
                method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
                method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                method eval_exp : exp -> (Bil.result, 'a) M.t
                method eval_extract :
                  int -> int -> exp -> (Bil.result, 'a) M.t
                method eval_int : word -> (Bil.result, 'a) M.t
                method eval_ite :
                  cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                method eval_load :
                  mem:exp ->
                  addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                method eval_store :
                  mem:exp ->
                  addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                method eval_unknown :
                  Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                method eval_var : var -> (Bil.result, 'a) M.t
                method load : Bil.storage -> addr -> 'a r
                method lookup : var -> 'a r
                method store : Bil.storage -> addr -> word -> 'a r
                method type_error : type_error -> 'a r
                method undefined_addr : addr -> 'a r
                method undefined_var : var -> 'a r
                method update : var -> Bil.result -> 'a u
              end
          end
      type ('a, 'e) state = ('a, 'e) Legacy.Monad.State.t
      type 'a u = (unit, 'a) state
      type 'a r = (Bil.result, 'a) state
      module M : sig type ('a, 'e) t = ('a, 'e) state end
      module Eval :
        sig
          class type ['a, 'r] semantics = ['a, 'r] Eval.T2(M).semantics
          class type virtual ['a, 'r, 's] domain =
            ['a, 'r, 's] Eval.T2(M).domain
          class type virtual ['a, 'r, 's] eff = ['a, 'r, 's] Eval.T2(M).eff
          class virtual ['a, 'r, 's] t :
            object
              method division_by_zero : unit -> ('r, 'a) state
              method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
              method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
              method eval_concat : exp -> exp -> ('r, 'a) M.t
              method eval_exp : exp -> ('r, 'a) M.t
              method eval_extract : int -> int -> exp -> ('r, 'a) M.t
              method eval_int : word -> ('r, 'a) M.t
              method eval_ite : cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
              method eval_let : var -> exp -> exp -> ('r, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
              method eval_store :
                mem:exp -> addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
              method eval_unop : unop -> exp -> ('r, 'a) M.t
              method eval_var : var -> ('r, 'a) M.t
              method virtual load : '-> addr -> ('r, 'a) M.t
              method virtual lookup : var -> ('r, 'a) M.t
              method private virtual storage_of_value :
                '-> ('s option, 'a) M.t
              method virtual store : '-> addr -> word -> ('r, 'a) M.t
              method type_error : type_error -> ('r, 'a) state
              method private virtual undefined : ('r, 'a) M.t
              method virtual update : var -> '-> (unit, 'a) M.t
              method private virtual value_of_word : word -> ('r, 'a) M.t
              method private virtual word_of_value :
                '-> (word option, 'a) M.t
            end
        end
      class ['a] t :
        object
          constraint 'a = #context
          method division_by_zero : unit -> 'a r
          method empty : Bil.storage
          method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
          method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
          method eval_exp : exp -> (Bil.result, 'a) M.t
          method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
          method eval_int : word -> (Bil.result, 'a) M.t
          method eval_ite :
            cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
          method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_load :
            mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_store :
            mem:exp ->
            addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_unknown :
            Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
          method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
          method eval_var : var -> (Bil.result, 'a) M.t
          method load : Bil.storage -> addr -> 'a r
          method lookup : var -> 'a r
          method store : Bil.storage -> addr -> word -> 'a r
          method type_error : type_error -> 'a r
          method undefined_addr : addr -> 'a r
          method undefined_var : var -> 'a r
          method update : var -> Bil.result -> 'a u
        end
    end
  class ['a] expi :
    object
      constraint 'a = #Bap.Std.Expi.context
      method division_by_zero : unit -> 'Expi.r
      method empty : Bil.storage
      method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
      method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
      method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
      method eval_exp : exp -> (Bil.result, 'a) M.t
      method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
      method eval_int : word -> (Bil.result, 'a) M.t
      method eval_ite : cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
      method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
      method eval_load :
        mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
      method eval_store :
        mem:exp -> addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
      method eval_unknown :
        Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
      method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
      method eval_var : var -> (Bil.result, 'a) M.t
      method load : Bil.storage -> addr -> 'Expi.r
      method lookup : var -> 'Expi.r
      method store : Bil.storage -> addr -> word -> 'Expi.r
      method type_error : type_error -> 'Expi.r
      method undefined_addr : addr -> 'Expi.r
      method undefined_var : var -> 'Expi.r
      method update : var -> Bil.result -> 'Expi.u
    end
  module Bili :
    sig
      class context :
        object ('a)
          method bindings : (Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
          method create_storage :
            Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
          method create_undefined : 'a * Bap.Std.Bil.result
          method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
          method lookup : Bap.Std.var -> Bap.Std.Bil.result option
          method pc : Bap.Std.Bil.value
          method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
          method with_pc : Bap.Std.Bil.value -> 'a
        end
      module type S =
        sig
          type ('a, 'e) state
          type 'a u = (unit, 'a) Bap.Std.Bili.S.state
          type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Bili.S.state
          module Expi :
            sig
              type ('a, 'e) state = ('a, 'e) state
              type 'a u = (unit, 'a) state
              type 'a r = (Bil.result, 'a) state
              module M : sig type ('a, 'e) t = ('a, 'e) state end
              module Eval :
                sig
                  class type ['a, 'r] semantics =
                    ['a, 'r] Eval.T2(M).semantics
                  class type virtual ['a, 'r, 's] domain =
                    ['a, 'r, 's] Eval.T2(M).domain
                  class type virtual ['a, 'r, 's] eff =
                    ['a, 'r, 's] Eval.T2(M).eff
                  class virtual ['a, 'r, 's] t :
                    object
                      method division_by_zero : unit -> ('r, 'a) state
                      method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                      method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                      method eval_concat : exp -> exp -> ('r, 'a) M.t
                      method eval_exp : exp -> ('r, 'a) M.t
                      method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                      method eval_int : word -> ('r, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                      method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                      method eval_load :
                        mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                      method eval_unop : unop -> exp -> ('r, 'a) M.t
                      method eval_var : var -> ('r, 'a) M.t
                      method virtual load : '-> addr -> ('r, 'a) M.t
                      method virtual lookup : var -> ('r, 'a) M.t
                      method private virtual storage_of_value :
                        '-> ('s option, 'a) M.t
                      method virtual store :
                        '-> addr -> word -> ('r, 'a) M.t
                      method type_error : type_error -> ('r, 'a) state
                      method private virtual undefined : ('r, 'a) M.t
                      method virtual update : var -> '-> (unit, 'a) M.t
                      method private virtual value_of_word :
                        word -> ('r, 'a) M.t
                      method private virtual word_of_value :
                        '-> (word option, 'a) M.t
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Expi.context
                  method division_by_zero : unit -> 'a r
                  method empty : Bil.storage
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method load : Bil.storage -> addr -> 'a r
                  method lookup : var -> 'a r
                  method store : Bil.storage -> addr -> word -> 'a r
                  method type_error : type_error -> 'a r
                  method undefined_addr : addr -> 'a r
                  method undefined_var : var -> 'a r
                  method update : var -> Bil.result -> 'a u
                end
            end
          class ['a] t :
            object
              constraint 'a = #Bap.Std.Bili.context
              method division_by_zero : unit -> 'Expi.r
              method empty : Bil.storage
              method eval : Bap.Std.stmt list -> 'Bap.Std.Bili.S.u
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_cpuexn : int -> 'Bap.Std.Bili.S.u
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_if :
                cond:Bap.Std.exp ->
                yes:Bap.Std.stmt list ->
                no:Bap.Std.stmt list -> 'Bap.Std.Bili.S.u
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_jmp : Bap.Std.exp -> 'Bap.Std.Bili.S.u
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_move :
                Bap.Std.var -> Bap.Std.exp -> 'Bap.Std.Bili.S.u
              method eval_special : string -> 'Bap.Std.Bili.S.u
              method eval_stmt : Bap.Std.stmt -> 'Bap.Std.Bili.S.u
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method eval_while :
                cond:Bap.Std.exp ->
                body:Bap.Std.stmt list -> 'Bap.Std.Bili.S.u
              method load : Bil.storage -> addr -> 'Expi.r
              method lookup : var -> 'Expi.r
              method store : Bil.storage -> addr -> word -> 'Expi.r
              method type_error : type_error -> 'Expi.r
              method undefined_addr : addr -> 'Expi.r
              method undefined_var : var -> 'Expi.r
              method update : var -> Bil.result -> 'Expi.u
            end
        end
      module Make :
        functor (M : Monads.Std.Monad.State.S2->
          sig
            type ('a, 'e) state = ('a, 'e) M.t
            type 'a u = (unit, 'a) state
            type 'a r = (Bil.result, 'a) state
            module Expi :
              sig
                type ('a, 'e) state = ('a, 'e) M.t
                type 'a u = (unit, 'a) state
                type 'a r = (Bil.result, 'a) state
                module M : sig type ('a, 'e) t = ('a, 'e) state end
                module Eval :
                  sig
                    class type ['a, 'r] semantics =
                      ['a, 'r] Eval.T2(M).semantics
                    class type virtual ['a, 'r, 's] domain =
                      ['a, 'r, 's] Eval.T2(M).domain
                    class type virtual ['a, 'r, 's] eff =
                      ['a, 'r, 's] Eval.T2(M).eff
                    class virtual ['a, 'r, 's] t :
                      object
                        method division_by_zero : unit -> ('r, 'a) state
                        method eval_binop :
                          binop -> exp -> exp -> ('r, 'a) M.t
                        method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                        method eval_concat : exp -> exp -> ('r, 'a) M.t
                        method eval_exp : exp -> ('r, 'a) M.t
                        method eval_extract :
                          int -> int -> exp -> ('r, 'a) M.t
                        method eval_int : word -> ('r, 'a) M.t
                        method eval_ite :
                          cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                        method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                        method eval_load :
                          mem:exp ->
                          addr:exp -> endian -> size -> ('r, 'a) M.t
                        method eval_store :
                          mem:exp ->
                          addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                        method eval_unknown :
                          Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                        method eval_unop : unop -> exp -> ('r, 'a) M.t
                        method eval_var : var -> ('r, 'a) M.t
                        method virtual load : '-> addr -> ('r, 'a) M.t
                        method virtual lookup : var -> ('r, 'a) M.t
                        method private virtual storage_of_value :
                          '-> ('s option, 'a) M.t
                        method virtual store :
                          '-> addr -> word -> ('r, 'a) M.t
                        method type_error : type_error -> ('r, 'a) state
                        method private virtual undefined : ('r, 'a) M.t
                        method virtual update : var -> '-> (unit, 'a) M.t
                        method private virtual value_of_word :
                          word -> ('r, 'a) M.t
                        method private virtual word_of_value :
                          '-> (word option, 'a) M.t
                      end
                  end
                class ['a] t :
                  object
                    constraint 'a = #Expi.context
                    method division_by_zero : unit -> 'a r
                    method empty : Bil.storage
                    method eval_binop :
                      binop -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_cast :
                      cast -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                    method eval_exp : exp -> (Bil.result, 'a) M.t
                    method eval_extract :
                      int -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_int : word -> (Bil.result, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                    method eval_let :
                      var -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_load :
                      mem:exp ->
                      addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_store :
                      mem:exp ->
                      addr:exp ->
                      exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                    method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                    method eval_var : var -> (Bil.result, 'a) M.t
                    method load : Bil.storage -> addr -> 'a r
                    method lookup : var -> 'a r
                    method store : Bil.storage -> addr -> word -> 'a r
                    method type_error : type_error -> 'a r
                    method undefined_addr : addr -> 'a r
                    method undefined_var : var -> 'a r
                    method update : var -> Bil.result -> 'a u
                  end
              end
            class ['a] t :
              object
                constraint 'a = #context
                method division_by_zero : unit -> 'Expi.r
                method empty : Bil.storage
                method eval : stmt list -> 'a u
                method eval_binop :
                  binop -> exp -> exp -> (Bil.result, 'a) M.t
                method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
                method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                method eval_cpuexn : int -> 'a u
                method eval_exp : exp -> (Bil.result, 'a) M.t
                method eval_extract :
                  int -> int -> exp -> (Bil.result, 'a) M.t
                method eval_if :
                  cond:exp -> yes:stmt list -> no:stmt list -> 'a u
                method eval_int : word -> (Bil.result, 'a) M.t
                method eval_ite :
                  cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                method eval_jmp : exp -> 'a u
                method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                method eval_load :
                  mem:exp ->
                  addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                method eval_move : var -> exp -> 'a u
                method eval_special : Trie.String.Suffix.key -> 'a u
                method eval_stmt : stmt -> 'a u
                method eval_store :
                  mem:exp ->
                  addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                method eval_unknown :
                  Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                method eval_var : var -> (Bil.result, 'a) M.t
                method eval_while : cond:exp -> body:stmt list -> 'a u
                method load : Bil.storage -> addr -> 'Expi.r
                method lookup : var -> 'Expi.r
                method store : Bil.storage -> addr -> word -> 'Expi.r
                method type_error : type_error -> 'Expi.r
                method undefined_addr : addr -> 'Expi.r
                method undefined_var : var -> 'Expi.r
                method update : var -> Bil.result -> 'Expi.u
              end
          end
      type ('a, 'e) state = ('a, 'e) Expi.state
      type 'a u = (unit, 'a) state
      type 'a r = (Bil.result, 'a) state
      module Expi :
        sig
          type ('a, 'e) state = ('a, 'e) Expi.state
          type 'a u = (unit, 'a) state
          type 'a r = (Bil.result, 'a) state
          module M : sig type ('a, 'e) t = ('a, 'e) state end
          module Eval :
            sig
              class type ['a, 'r] semantics = ['a, 'r] Eval.T2(M).semantics
              class type virtual ['a, 'r, 's] domain =
                ['a, 'r, 's] Eval.T2(M).domain
              class type virtual ['a, 'r, 's] eff =
                ['a, 'r, 's] Eval.T2(M).eff
              class virtual ['a, 'r, 's] t :
                object
                  method division_by_zero : unit -> ('r, 'a) state
                  method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                  method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                  method eval_concat : exp -> exp -> ('r, 'a) M.t
                  method eval_exp : exp -> ('r, 'a) M.t
                  method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                  method eval_int : word -> ('r, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                  method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                  method eval_load :
                    mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                  method eval_unop : unop -> exp -> ('r, 'a) M.t
                  method eval_var : var -> ('r, 'a) M.t
                  method virtual load : '-> addr -> ('r, 'a) M.t
                  method virtual lookup : var -> ('r, 'a) M.t
                  method private virtual storage_of_value :
                    '-> ('s option, 'a) M.t
                  method virtual store : '-> addr -> word -> ('r, 'a) M.t
                  method type_error : type_error -> ('r, 'a) state
                  method private virtual undefined : ('r, 'a) M.t
                  method virtual update : var -> '-> (unit, 'a) M.t
                  method private virtual value_of_word : word -> ('r, 'a) M.t
                  method private virtual word_of_value :
                    '-> (word option, 'a) M.t
                end
            end
          class ['a] t :
            object
              constraint 'a = #Expi.context
              method division_by_zero : unit -> 'a r
              method empty : Bil.storage
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method load : Bil.storage -> addr -> 'a r
              method lookup : var -> 'a r
              method store : Bil.storage -> addr -> word -> 'a r
              method type_error : type_error -> 'a r
              method undefined_addr : addr -> 'a r
              method undefined_var : var -> 'a r
              method update : var -> Bil.result -> 'a u
            end
        end
      class ['a] t :
        object
          constraint 'a = #context
          method division_by_zero : unit -> 'Expi.r
          method empty : Bil.storage
          method eval : stmt list -> 'a u
          method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
          method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
          method eval_cpuexn : int -> 'a u
          method eval_exp : exp -> (Bil.result, 'a) M.t
          method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
          method eval_if : cond:exp -> yes:stmt list -> no:stmt list -> 'a u
          method eval_int : word -> (Bil.result, 'a) M.t
          method eval_ite :
            cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
          method eval_jmp : exp -> 'a u
          method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_load :
            mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_move : var -> exp -> 'a u
          method eval_special : Trie.String.Suffix.key -> 'a u
          method eval_stmt : stmt -> 'a u
          method eval_store :
            mem:exp ->
            addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_unknown :
            Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
          method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
          method eval_var : var -> (Bil.result, 'a) M.t
          method eval_while : cond:exp -> body:stmt list -> 'a u
          method load : Bil.storage -> addr -> 'Expi.r
          method lookup : var -> 'Expi.r
          method store : Bil.storage -> addr -> word -> 'Expi.r
          method type_error : type_error -> 'Expi.r
          method undefined_addr : addr -> 'Expi.r
          method undefined_var : var -> 'Expi.r
          method update : var -> Bil.result -> 'Expi.u
        end
    end
  class ['a] bili :
    object
      constraint 'a = #Bap.Std.Bili.context
      method division_by_zero : unit -> 'Bili.Expi.r
      method empty : Bil.storage
      method eval : stmt list -> 'Bili.u
      method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
      method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
      method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
      method eval_cpuexn : int -> 'Bili.u
      method eval_exp : exp -> (Bil.result, 'a) M.t
      method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
      method eval_if : cond:exp -> yes:stmt list -> no:stmt list -> 'Bili.u
      method eval_int : word -> (Bil.result, 'a) M.t
      method eval_ite : cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
      method eval_jmp : exp -> 'Bili.u
      method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
      method eval_load :
        mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
      method eval_move : var -> exp -> 'Bili.u
      method eval_special : Trie.String.Suffix.key -> 'Bili.u
      method eval_stmt : stmt -> 'Bili.u
      method eval_store :
        mem:exp -> addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
      method eval_unknown :
        Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
      method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
      method eval_var : var -> (Bil.result, 'a) M.t
      method eval_while : cond:exp -> body:stmt list -> 'Bili.u
      method load : Bil.storage -> addr -> 'Bili.Expi.r
      method lookup : var -> 'Bili.Expi.r
      method store : Bil.storage -> addr -> word -> 'Bili.Expi.r
      method type_error : type_error -> 'Bili.Expi.r
      method undefined_addr : addr -> 'Bili.Expi.r
      method undefined_var : var -> 'Bili.Expi.r
      method update : var -> Bil.result -> 'Bili.Expi.u
    end
  module Eff :
    sig
      type t
      val none : Bap.Std.Eff.t
      val read : Bap.Std.Eff.t
      val load : Bap.Std.Eff.t
      val store : Bap.Std.Eff.t
      val raise : Bap.Std.Eff.t
      val reads : Bap.Std.Eff.t -> bool
      val loads : Bap.Std.Eff.t -> bool
      val stores : Bap.Std.Eff.t -> bool
      val raises : Bap.Std.Eff.t -> bool
      val has_effects : Bap.Std.Eff.t -> bool
      val has_coeffects : Bap.Std.Eff.t -> bool
      val compute : Bap.Std.exp -> Bap.Std.Eff.t
    end
  module Exp :
    sig
      type t = Bap.Std.Bil.exp
      class state :
        object
          val exps_stack : Bap.Std.exp list
          val under_condition : bool
        end
      class ['a] visitor :
        object
          val exps_stack : exp list
          val under_condition : bool
          method enter_binop :
            Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
          method enter_cast :
            Bap.Std.cast -> int -> Bap.Std.Exp.t -> '-> 'a
          method enter_concat : Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
          method enter_exp : Bap.Std.Exp.t -> '-> 'a
          method enter_extract :
            hi:int -> lo:int -> Bap.Std.Exp.t -> '-> 'a
          method enter_int : Bap.Std.word -> '-> 'a
          method enter_ite :
            cond:Bap.Std.Exp.t ->
            yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> '-> 'a
          method enter_let :
            Bap.Std.var ->
            exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> '-> 'a
          method enter_load :
            mem:Bap.Std.Exp.t ->
            addr:Bap.Std.Exp.t -> Bap.Std.endian -> Bap.Std.size -> '-> 'a
          method enter_store :
            mem:Bap.Std.Exp.t ->
            addr:Bap.Std.Exp.t ->
            exp:Bap.Std.Exp.t -> Bap.Std.endian -> Bap.Std.size -> '-> 'a
          method enter_unknown : string -> Bap.Std.typ -> '-> 'a
          method enter_unop : Bap.Std.unop -> Bap.Std.Exp.t -> '-> 'a
          method enter_var : Bap.Std.var -> '-> 'a
          method leave_binop :
            Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
          method leave_cast :
            Bap.Std.cast -> int -> Bap.Std.Exp.t -> '-> 'a
          method leave_concat : Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
          method leave_exp : Bap.Std.Exp.t -> '-> 'a
          method leave_extract :
            hi:int -> lo:int -> Bap.Std.Exp.t -> '-> 'a
          method leave_int : Bap.Std.word -> '-> 'a
          method leave_ite :
            cond:Bap.Std.Exp.t ->
            yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> '-> 'a
          method leave_let :
            Bap.Std.var ->
            exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> '-> 'a
          method leave_load :
            mem:Bap.Std.Exp.t ->
            addr:Bap.Std.Exp.t -> Bap.Std.endian -> Bap.Std.size -> '-> 'a
          method leave_store :
            mem:Bap.Std.Exp.t ->
            addr:Bap.Std.Exp.t ->
            exp:Bap.Std.Exp.t -> Bap.Std.endian -> Bap.Std.size -> '-> 'a
          method leave_unknown : string -> Bap.Std.typ -> '-> 'a
          method leave_unop : Bap.Std.unop -> Bap.Std.Exp.t -> '-> 'a
          method leave_var : Bap.Std.var -> '-> 'a
          method visit_binop :
            Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
          method visit_cast :
            Bap.Std.cast -> int -> Bap.Std.Exp.t -> '-> 'a
          method visit_concat : Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
          method visit_exp : Bap.Std.Exp.t -> '-> 'a
          method visit_extract :
            hi:int -> lo:int -> Bap.Std.Exp.t -> '-> 'a
          method visit_int : Bap.Std.word -> '-> 'a
          method visit_ite :
            cond:Bap.Std.Exp.t ->
            yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> '-> 'a
          method visit_let :
            Bap.Std.var ->
            exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> '-> 'a
          method visit_load :
            mem:Bap.Std.Exp.t ->
            addr:Bap.Std.Exp.t -> Bap.Std.endian -> Bap.Std.size -> '-> 'a
          method visit_store :
            mem:Bap.Std.Exp.t ->
            addr:Bap.Std.Exp.t ->
            exp:Bap.Std.Exp.t -> Bap.Std.endian -> Bap.Std.size -> '-> 'a
          method visit_unknown : string -> Bap.Std.typ -> '-> 'a
          method visit_unop : Bap.Std.unop -> Bap.Std.Exp.t -> '-> 'a
          method visit_var : Bap.Std.var -> '-> 'a
        end
      class ['a] finder :
        object
          val exps_stack : exp list
          val under_condition : bool
          method enter_binop :
            binop ->
            t ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_cast :
            cast ->
            int ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_concat :
            t ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_exp :
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_extract :
            hi:int ->
            lo:int ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_int :
            word ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_ite :
            cond:t ->
            yes:t ->
            no:t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_let :
            var ->
            exp:t ->
            body:t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_load :
            mem:t ->
            addr:t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_store :
            mem:t ->
            addr:t ->
            exp:t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_unknown :
            Trie.String.Suffix.key ->
            typ ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_unop :
            unop ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_var :
            var ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method find : Bap.Std.Exp.t -> 'a option
          method leave_binop :
            binop ->
            t ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_cast :
            cast ->
            int ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_concat :
            t ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_exp :
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_extract :
            hi:int ->
            lo:int ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_int :
            word ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_ite :
            cond:t ->
            yes:t ->
            no:t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_let :
            var ->
            exp:t ->
            body:t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_load :
            mem:t ->
            addr:t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_store :
            mem:t ->
            addr:t ->
            exp:t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_unknown :
            Trie.String.Suffix.key ->
            typ ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_unop :
            unop ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_var :
            var ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_binop :
            binop ->
            t ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_cast :
            cast ->
            int ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_concat :
            t ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_exp :
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_extract :
            hi:int ->
            lo:int ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_int :
            word ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_ite :
            cond:t ->
            yes:t ->
            no:t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_let :
            var ->
            exp:t ->
            body:t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_load :
            mem:t ->
            addr:t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_store :
            mem:t ->
            addr:t ->
            exp:t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_unknown :
            Trie.String.Suffix.key ->
            typ ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_unop :
            unop ->
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_var :
            var ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
        end
      class mapper :
        object
          val exps_stack : exp list
          val under_condition : bool
          method map_binop :
            Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> Bap.Std.Exp.t
          method map_cast :
            Bap.Std.cast -> int -> Bap.Std.Exp.t -> Bap.Std.Exp.t
          method map_concat : Bap.Std.Exp.t -> Bap.Std.Exp.t -> Bap.Std.Exp.t
          method map_exp : Bap.Std.Exp.t -> Bap.Std.Exp.t
          method map_extract :
            hi:int -> lo:int -> Bap.Std.Exp.t -> Bap.Std.Exp.t
          method map_int : Bap.Std.word -> Bap.Std.Exp.t
          method map_ite :
            cond:Bap.Std.Exp.t ->
            yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> Bap.Std.Exp.t
          method map_let :
            Bap.Std.var ->
            exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> Bap.Std.Exp.t
          method map_load :
            mem:Bap.Std.Exp.t ->
            addr:Bap.Std.Exp.t ->
            Bap.Std.endian -> Bap.Std.size -> Bap.Std.Exp.t
          method map_store :
            mem:Bap.Std.Exp.t ->
            addr:Bap.Std.Exp.t ->
            exp:Bap.Std.Exp.t ->
            Bap.Std.endian -> Bap.Std.size -> Bap.Std.Exp.t
          method map_sym : Bap.Std.var -> Bap.Std.var
          method map_unknown : string -> Bap.Std.typ -> Bap.Std.Exp.t
          method map_unop : Bap.Std.unop -> Bap.Std.Exp.t -> Bap.Std.Exp.t
          method map_var : Bap.Std.var -> Bap.Std.Exp.t
        end
      val fold : '#Bap.Std.Exp.visitor -> init:'-> Bap.Std.Exp.t -> 'a
      val iter : unit #Bap.Std.Exp.visitor -> Bap.Std.Exp.t -> unit
      val find : '#Bap.Std.Exp.finder -> Bap.Std.Exp.t -> 'a option
      val map : #Bap.Std.Exp.mapper -> Bap.Std.Exp.t -> Bap.Std.Exp.t
      val exists : unit #Bap.Std.Exp.finder -> Bap.Std.Exp.t -> bool
      val substitute :
        Bap.Std.exp -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.exp
      val normalize : Bap.Std.exp -> Bap.Std.exp
      val simpl : ?ignore:Bap.Std.Eff.t list -> Bap.Std.exp -> Bap.Std.exp
      val is_referenced : Bap.Std.var -> Bap.Std.Exp.t -> bool
      val normalize_negatives : Bap.Std.Exp.t -> Bap.Std.Exp.t
      val fold_consts : Bap.Std.Exp.t -> Bap.Std.Exp.t
      val fixpoint :
        (Bap.Std.Exp.t -> Bap.Std.Exp.t) -> Bap.Std.Exp.t -> Bap.Std.Exp.t
      val free_vars : Bap.Std.Exp.t -> Bap.Std.Var.Set.t
      val eval : Bap.Std.Exp.t -> Bap.Std.Bil.value
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.Bil.exp
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Type_error.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Type_error.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Type_error.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Type_error.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Type_error.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
      val pp_adt : Bap.Std.Exp.t Regular.Std.printer
    end
  module Stmt :
    sig
      type t = Bap.Std.Bil.stmt
      class state :
        object
          val in_jmp : bool
          val in_loop : bool
          val in_move : bool
          val preds : Bap.Std.stmt list
          val stmts_stack : Bap.Std.stmt list
          val succs : Bap.Std.stmt list
        end
      class ['a] visitor :
        object
          val exps_stack : exp list
          val in_jmp : bool
          val in_loop : bool
          val in_move : bool
          val preds : stmt list
          val stmts_stack : stmt list
          val succs : stmt list
          val under_condition : bool
          method enter_binop : binop -> Exp.t -> Exp.t -> '-> 'a
          method enter_cast : cast -> int -> Exp.t -> '-> 'a
          method enter_concat : Exp.t -> Exp.t -> '-> 'a
          method enter_cpuexn : int -> '-> 'a
          method enter_exp : Exp.t -> '-> 'a
          method enter_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
          method enter_if :
            cond:Bap.Std.exp ->
            yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> '-> 'a
          method enter_int : word -> '-> 'a
          method enter_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
          method enter_jmp : Bap.Std.exp -> '-> 'a
          method enter_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
          method enter_load :
            mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
          method enter_move : Bap.Std.var -> Bap.Std.exp -> '-> 'a
          method enter_special : string -> '-> 'a
          method enter_stmt : Bap.Std.Stmt.t -> '-> 'a
          method enter_store :
            mem:Exp.t ->
            addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
          method enter_unknown : Trie.String.Suffix.key -> typ -> '-> 'a
          method enter_unop : unop -> Exp.t -> '-> 'a
          method enter_var : var -> '-> 'a
          method enter_while :
            cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> '-> 'a
          method leave_binop : binop -> Exp.t -> Exp.t -> '-> 'a
          method leave_cast : cast -> int -> Exp.t -> '-> 'a
          method leave_concat : Exp.t -> Exp.t -> '-> 'a
          method leave_cpuexn : int -> '-> 'a
          method leave_exp : Exp.t -> '-> 'a
          method leave_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
          method leave_if :
            cond:Bap.Std.exp ->
            yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> '-> 'a
          method leave_int : word -> '-> 'a
          method leave_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
          method leave_jmp : Bap.Std.exp -> '-> 'a
          method leave_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
          method leave_load :
            mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
          method leave_move : Bap.Std.var -> Bap.Std.exp -> '-> 'a
          method leave_special : string -> '-> 'a
          method leave_stmt : Bap.Std.Stmt.t -> '-> 'a
          method leave_store :
            mem:Exp.t ->
            addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
          method leave_unknown : Trie.String.Suffix.key -> typ -> '-> 'a
          method leave_unop : unop -> Exp.t -> '-> 'a
          method leave_var : var -> '-> 'a
          method leave_while :
            cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> '-> 'a
          method run : Bap.Std.Stmt.t list -> '-> 'a
          method visit_binop : binop -> Exp.t -> Exp.t -> '-> 'a
          method visit_cast : cast -> int -> Exp.t -> '-> 'a
          method visit_concat : Exp.t -> Exp.t -> '-> 'a
          method visit_cpuexn : int -> '-> 'a
          method visit_exp : Exp.t -> '-> 'a
          method visit_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
          method visit_if :
            cond:Bap.Std.exp ->
            yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> '-> 'a
          method visit_int : word -> '-> 'a
          method visit_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
          method visit_jmp : Bap.Std.exp -> '-> 'a
          method visit_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
          method visit_load :
            mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
          method visit_move : Bap.Std.var -> Bap.Std.exp -> '-> 'a
          method visit_special : string -> '-> 'a
          method visit_stmt : Bap.Std.Stmt.t -> '-> 'a
          method visit_store :
            mem:Exp.t ->
            addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
          method visit_unknown : Trie.String.Suffix.key -> typ -> '-> 'a
          method visit_unop : unop -> Exp.t -> '-> 'a
          method visit_var : var -> '-> 'a
          method visit_while :
            cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> '-> 'a
        end
      class ['a] finder :
        object
          val exps_stack : exp list
          val in_jmp : bool
          val in_loop : bool
          val in_move : bool
          val preds : stmt list
          val stmts_stack : stmt list
          val succs : stmt list
          val under_condition : bool
          method enter_binop :
            binop ->
            Exp.t ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_cast :
            cast ->
            int ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_concat :
            Exp.t ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_cpuexn :
            int ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_exp :
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_extract :
            hi:int ->
            lo:int ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_if :
            cond:exp ->
            yes:t list ->
            no:t list ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_int :
            word ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_ite :
            cond:Exp.t ->
            yes:Exp.t ->
            no:Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_jmp :
            exp ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_let :
            var ->
            exp:Exp.t ->
            body:Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_load :
            mem:Exp.t ->
            addr:Exp.t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_move :
            var ->
            exp ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_special :
            Trie.String.Suffix.key ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_stmt :
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_store :
            mem:Exp.t ->
            addr:Exp.t ->
            exp:Exp.t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_unknown :
            Trie.String.Suffix.key ->
            typ ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_unop :
            unop ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_var :
            var ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method enter_while :
            cond:exp ->
            t list ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method find : Bap.Std.Stmt.t list -> 'a option
          method leave_binop :
            binop ->
            Exp.t ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_cast :
            cast ->
            int ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_concat :
            Exp.t ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_cpuexn :
            int ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_exp :
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_extract :
            hi:int ->
            lo:int ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_if :
            cond:exp ->
            yes:t list ->
            no:t list ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_int :
            word ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_ite :
            cond:Exp.t ->
            yes:Exp.t ->
            no:Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_jmp :
            exp ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_let :
            var ->
            exp:Exp.t ->
            body:Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_load :
            mem:Exp.t ->
            addr:Exp.t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_move :
            var ->
            exp ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_special :
            Trie.String.Suffix.key ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_stmt :
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_store :
            mem:Exp.t ->
            addr:Exp.t ->
            exp:Exp.t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_unknown :
            Trie.String.Suffix.key ->
            typ ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_unop :
            unop ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_var :
            var ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method leave_while :
            cond:exp ->
            t list ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method run :
            t list ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_binop :
            binop ->
            Exp.t ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_cast :
            cast ->
            int ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_concat :
            Exp.t ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_cpuexn :
            int ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_exp :
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_extract :
            hi:int ->
            lo:int ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_if :
            cond:exp ->
            yes:t list ->
            no:t list ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_int :
            word ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_ite :
            cond:Exp.t ->
            yes:Exp.t ->
            no:Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_jmp :
            exp ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_let :
            var ->
            exp:Exp.t ->
            body:Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_load :
            mem:Exp.t ->
            addr:Exp.t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_move :
            var ->
            exp ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_special :
            Trie.String.Suffix.key ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_stmt :
            t -> 'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_store :
            mem:Exp.t ->
            addr:Exp.t ->
            exp:Exp.t ->
            endian ->
            size ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_unknown :
            Trie.String.Suffix.key ->
            typ ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_unop :
            unop ->
            Exp.t ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_var :
            var ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
          method visit_while :
            cond:exp ->
            t list ->
            'a option Core_kernel.return -> 'a option Core_kernel.return
        end
      class mapper :
        object
          val exps_stack : exp list
          val in_jmp : bool
          val in_loop : bool
          val in_move : bool
          val preds : stmt list
          val stmts_stack : stmt list
          val succs : stmt list
          val under_condition : bool
          method map_binop : binop -> Exp.t -> Exp.t -> Exp.t
          method map_cast : cast -> int -> Exp.t -> Exp.t
          method map_concat : Exp.t -> Exp.t -> Exp.t
          method map_cpuexn : int -> Bap.Std.Stmt.t list
          method map_exp : Exp.t -> Exp.t
          method map_extract : hi:int -> lo:int -> Exp.t -> Exp.t
          method map_if :
            cond:Bap.Std.exp ->
            yes:Bap.Std.Stmt.t list ->
            no:Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
          method map_int : word -> Exp.t
          method map_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> Exp.t
          method map_jmp : Bap.Std.exp -> Bap.Std.Stmt.t list
          method map_let : var -> exp:Exp.t -> body:Exp.t -> Exp.t
          method map_load :
            mem:Exp.t -> addr:Exp.t -> endian -> size -> Exp.t
          method map_move : Bap.Std.var -> Bap.Std.exp -> Bap.Std.Stmt.t list
          method map_special : string -> Bap.Std.Stmt.t list
          method map_stmt : Bap.Std.Stmt.t -> Bap.Std.Stmt.t list
          method map_store :
            mem:Exp.t -> addr:Exp.t -> exp:Exp.t -> endian -> size -> Exp.t
          method map_sym : var -> var
          method map_unknown : Trie.String.Suffix.key -> typ -> Exp.t
          method map_unop : unop -> Exp.t -> Exp.t
          method map_var : var -> Exp.t
          method map_while :
            cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
          method run : Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
        end
      class constant_folder : mapper
      val fold : '#Bap.Std.Stmt.visitor -> init:'-> Bap.Std.Stmt.t -> 'a
      val iter : unit #Bap.Std.Stmt.visitor -> Bap.Std.Stmt.t -> unit
      val map :
        #Bap.Std.Stmt.mapper -> Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
      val find : '#Bap.Std.Stmt.finder -> Bap.Std.Stmt.t -> 'a option
      val exists : unit #Bap.Std.Stmt.finder -> Bap.Std.Stmt.t -> bool
      val is_referenced : Bap.Std.var -> Bap.Std.Stmt.t -> bool
      val normalize :
        ?normalize_exp:bool -> Bap.Std.stmt list -> Bap.Std.stmt list
      val simpl :
        ?ignore:Bap.Std.Eff.t list ->
        Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
      val fixpoint :
        (Bap.Std.Stmt.t -> Bap.Std.Stmt.t) ->
        Bap.Std.Stmt.t -> Bap.Std.Stmt.t
      val free_vars : Bap.Std.Stmt.t -> Bap.Std.Var.Set.t
      val eval : Bap.Std.Stmt.t list -> (#Bap.Std.Bili.context as 'a) -> 'a
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.Bil.stmt
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Exp.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Exp.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Exp.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Exp.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Exp.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
      val pp_adt : Bap.Std.Stmt.t Regular.Std.printer
    end
  module Arch :
    sig
      type x86 = [ `x86 | `x86_64 ]
      val bin_x86 : x86 Core_kernel.Bin_prot.Type_class.t
      val bin_read_x86 : x86 Core_kernel.Bin_prot.Read.reader
      val __bin_read_x86__ : (int -> x86) Core_kernel.Bin_prot.Read.reader
      val bin_reader_x86 : x86 Core_kernel.Bin_prot.Type_class.reader
      val bin_size_x86 : x86 Core_kernel.Bin_prot.Size.sizer
      val bin_write_x86 : x86 Core_kernel.Bin_prot.Write.writer
      val bin_writer_x86 : x86 Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_x86 : Core_kernel.Bin_prot.Shape.t
      val compare_x86 : x86 -> x86 -> int
      val all_of_x86 : x86 list
      val x86_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> x86
      val __x86_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> x86
      val sexp_of_x86 : x86 -> Ppx_sexp_conv_lib.Sexp.t
      type arm = [ `armv4 | `armv5 | `armv6 | `armv7 ]
      val bin_arm : arm Core_kernel.Bin_prot.Type_class.t
      val bin_read_arm : arm Core_kernel.Bin_prot.Read.reader
      val __bin_read_arm__ : (int -> arm) Core_kernel.Bin_prot.Read.reader
      val bin_reader_arm : arm Core_kernel.Bin_prot.Type_class.reader
      val bin_size_arm : arm Core_kernel.Bin_prot.Size.sizer
      val bin_write_arm : arm Core_kernel.Bin_prot.Write.writer
      val bin_writer_arm : arm Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_arm : Core_kernel.Bin_prot.Shape.t
      val compare_arm : arm -> arm -> int
      val all_of_arm : arm list
      val arm_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> arm
      val __arm_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> arm
      val sexp_of_arm : arm -> Ppx_sexp_conv_lib.Sexp.t
      type armeb = [ `armv4eb | `armv5eb | `armv6eb | `armv7eb ]
      val bin_armeb : armeb Core_kernel.Bin_prot.Type_class.t
      val bin_read_armeb : armeb Core_kernel.Bin_prot.Read.reader
      val __bin_read_armeb__ :
        (int -> armeb) Core_kernel.Bin_prot.Read.reader
      val bin_reader_armeb : armeb Core_kernel.Bin_prot.Type_class.reader
      val bin_size_armeb : armeb Core_kernel.Bin_prot.Size.sizer
      val bin_write_armeb : armeb Core_kernel.Bin_prot.Write.writer
      val bin_writer_armeb : armeb Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_armeb : Core_kernel.Bin_prot.Shape.t
      val compare_armeb : armeb -> armeb -> int
      val all_of_armeb : armeb list
      val armeb_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> armeb
      val __armeb_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> armeb
      val sexp_of_armeb : armeb -> Ppx_sexp_conv_lib.Sexp.t
      type thumb = [ `thumbv4 | `thumbv5 | `thumbv6 | `thumbv7 ]
      val bin_thumb : thumb Core_kernel.Bin_prot.Type_class.t
      val bin_read_thumb : thumb Core_kernel.Bin_prot.Read.reader
      val __bin_read_thumb__ :
        (int -> thumb) Core_kernel.Bin_prot.Read.reader
      val bin_reader_thumb : thumb Core_kernel.Bin_prot.Type_class.reader
      val bin_size_thumb : thumb Core_kernel.Bin_prot.Size.sizer
      val bin_write_thumb : thumb Core_kernel.Bin_prot.Write.writer
      val bin_writer_thumb : thumb Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_thumb : Core_kernel.Bin_prot.Shape.t
      val compare_thumb : thumb -> thumb -> int
      val all_of_thumb : thumb list
      val thumb_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> thumb
      val __thumb_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> thumb
      val sexp_of_thumb : thumb -> Ppx_sexp_conv_lib.Sexp.t
      type thumbeb = [ `thumbv4eb | `thumbv5eb | `thumbv6eb | `thumbv7eb ]
      val bin_thumbeb : thumbeb Core_kernel.Bin_prot.Type_class.t
      val bin_read_thumbeb : thumbeb Core_kernel.Bin_prot.Read.reader
      val __bin_read_thumbeb__ :
        (int -> thumbeb) Core_kernel.Bin_prot.Read.reader
      val bin_reader_thumbeb : thumbeb Core_kernel.Bin_prot.Type_class.reader
      val bin_size_thumbeb : thumbeb Core_kernel.Bin_prot.Size.sizer
      val bin_write_thumbeb : thumbeb Core_kernel.Bin_prot.Write.writer
      val bin_writer_thumbeb : thumbeb Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_thumbeb : Core_kernel.Bin_prot.Shape.t
      val compare_thumbeb : thumbeb -> thumbeb -> int
      val all_of_thumbeb : thumbeb list
      val thumbeb_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> thumbeb
      val __thumbeb_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> thumbeb
      val sexp_of_thumbeb : thumbeb -> Ppx_sexp_conv_lib.Sexp.t
      type aarch64 = [ `aarch64 | `aarch64_be ]
      val bin_aarch64 : aarch64 Core_kernel.Bin_prot.Type_class.t
      val bin_read_aarch64 : aarch64 Core_kernel.Bin_prot.Read.reader
      val __bin_read_aarch64__ :
        (int -> aarch64) Core_kernel.Bin_prot.Read.reader
      val bin_reader_aarch64 : aarch64 Core_kernel.Bin_prot.Type_class.reader
      val bin_size_aarch64 : aarch64 Core_kernel.Bin_prot.Size.sizer
      val bin_write_aarch64 : aarch64 Core_kernel.Bin_prot.Write.writer
      val bin_writer_aarch64 : aarch64 Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_aarch64 : Core_kernel.Bin_prot.Shape.t
      val compare_aarch64 : aarch64 -> aarch64 -> int
      val all_of_aarch64 : aarch64 list
      val aarch64_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> aarch64
      val __aarch64_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> aarch64
      val sexp_of_aarch64 : aarch64 -> Ppx_sexp_conv_lib.Sexp.t
      type ppc = [ `ppc | `ppc64 | `ppc64le ]
      val bin_ppc : ppc Core_kernel.Bin_prot.Type_class.t
      val bin_read_ppc : ppc Core_kernel.Bin_prot.Read.reader
      val __bin_read_ppc__ : (int -> ppc) Core_kernel.Bin_prot.Read.reader
      val bin_reader_ppc : ppc Core_kernel.Bin_prot.Type_class.reader
      val bin_size_ppc : ppc Core_kernel.Bin_prot.Size.sizer
      val bin_write_ppc : ppc Core_kernel.Bin_prot.Write.writer
      val bin_writer_ppc : ppc Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_ppc : Core_kernel.Bin_prot.Shape.t
      val compare_ppc : ppc -> ppc -> int
      val all_of_ppc : ppc list
      val ppc_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> ppc
      val __ppc_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> ppc
      val sexp_of_ppc : ppc -> Ppx_sexp_conv_lib.Sexp.t
      type mips = [ `mips | `mips64 | `mips64el | `mipsel ]
      val bin_mips : mips Core_kernel.Bin_prot.Type_class.t
      val bin_read_mips : mips Core_kernel.Bin_prot.Read.reader
      val __bin_read_mips__ : (int -> mips) Core_kernel.Bin_prot.Read.reader
      val bin_reader_mips : mips Core_kernel.Bin_prot.Type_class.reader
      val bin_size_mips : mips Core_kernel.Bin_prot.Size.sizer
      val bin_write_mips : mips Core_kernel.Bin_prot.Write.writer
      val bin_writer_mips : mips Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_mips : Core_kernel.Bin_prot.Shape.t
      val compare_mips : mips -> mips -> int
      val all_of_mips : mips list
      val mips_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> mips
      val __mips_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> mips
      val sexp_of_mips : mips -> Ppx_sexp_conv_lib.Sexp.t
      type sparc = [ `sparc | `sparcv9 ]
      val bin_sparc : sparc Core_kernel.Bin_prot.Type_class.t
      val bin_read_sparc : sparc Core_kernel.Bin_prot.Read.reader
      val __bin_read_sparc__ :
        (int -> sparc) Core_kernel.Bin_prot.Read.reader
      val bin_reader_sparc : sparc Core_kernel.Bin_prot.Type_class.reader
      val bin_size_sparc : sparc Core_kernel.Bin_prot.Size.sizer
      val bin_write_sparc : sparc Core_kernel.Bin_prot.Write.writer
      val bin_writer_sparc : sparc Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_sparc : Core_kernel.Bin_prot.Shape.t
      val compare_sparc : sparc -> sparc -> int
      val all_of_sparc : sparc list
      val sparc_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> sparc
      val __sparc_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> sparc
      val sexp_of_sparc : sparc -> Ppx_sexp_conv_lib.Sexp.t
      type nvptx = [ `nvptx | `nvptx64 ]
      val bin_nvptx : nvptx Core_kernel.Bin_prot.Type_class.t
      val bin_read_nvptx : nvptx Core_kernel.Bin_prot.Read.reader
      val __bin_read_nvptx__ :
        (int -> nvptx) Core_kernel.Bin_prot.Read.reader
      val bin_reader_nvptx : nvptx Core_kernel.Bin_prot.Type_class.reader
      val bin_size_nvptx : nvptx Core_kernel.Bin_prot.Size.sizer
      val bin_write_nvptx : nvptx Core_kernel.Bin_prot.Write.writer
      val bin_writer_nvptx : nvptx Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_nvptx : Core_kernel.Bin_prot.Shape.t
      val compare_nvptx : nvptx -> nvptx -> int
      val all_of_nvptx : nvptx list
      val nvptx_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> nvptx
      val __nvptx_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> nvptx
      val sexp_of_nvptx : nvptx -> Ppx_sexp_conv_lib.Sexp.t
      type hexagon = [ `hexagon ]
      val bin_hexagon : hexagon Core_kernel.Bin_prot.Type_class.t
      val bin_read_hexagon : hexagon Core_kernel.Bin_prot.Read.reader
      val __bin_read_hexagon__ :
        (int -> hexagon) Core_kernel.Bin_prot.Read.reader
      val bin_reader_hexagon : hexagon Core_kernel.Bin_prot.Type_class.reader
      val bin_size_hexagon : hexagon Core_kernel.Bin_prot.Size.sizer
      val bin_write_hexagon : hexagon Core_kernel.Bin_prot.Write.writer
      val bin_writer_hexagon : hexagon Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_hexagon : Core_kernel.Bin_prot.Shape.t
      val compare_hexagon : hexagon -> hexagon -> int
      val all_of_hexagon : hexagon list
      val hexagon_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> hexagon
      val __hexagon_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> hexagon
      val sexp_of_hexagon : hexagon -> Ppx_sexp_conv_lib.Sexp.t
      type r600 = [ `r600 ]
      val bin_r600 : r600 Core_kernel.Bin_prot.Type_class.t
      val bin_read_r600 : r600 Core_kernel.Bin_prot.Read.reader
      val __bin_read_r600__ : (int -> r600) Core_kernel.Bin_prot.Read.reader
      val bin_reader_r600 : r600 Core_kernel.Bin_prot.Type_class.reader
      val bin_size_r600 : r600 Core_kernel.Bin_prot.Size.sizer
      val bin_write_r600 : r600 Core_kernel.Bin_prot.Write.writer
      val bin_writer_r600 : r600 Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_r600 : Core_kernel.Bin_prot.Shape.t
      val compare_r600 : r600 -> r600 -> int
      val all_of_r600 : r600 list
      val r600_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> r600
      val __r600_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> r600
      val sexp_of_r600 : r600 -> Ppx_sexp_conv_lib.Sexp.t
      type systemz = [ `systemz ]
      val bin_systemz : systemz Core_kernel.Bin_prot.Type_class.t
      val bin_read_systemz : systemz Core_kernel.Bin_prot.Read.reader
      val __bin_read_systemz__ :
        (int -> systemz) Core_kernel.Bin_prot.Read.reader
      val bin_reader_systemz : systemz Core_kernel.Bin_prot.Type_class.reader
      val bin_size_systemz : systemz Core_kernel.Bin_prot.Size.sizer
      val bin_write_systemz : systemz Core_kernel.Bin_prot.Write.writer
      val bin_writer_systemz : systemz Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_systemz : Core_kernel.Bin_prot.Shape.t
      val compare_systemz : systemz -> systemz -> int
      val all_of_systemz : systemz list
      val systemz_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> systemz
      val __systemz_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> systemz
      val sexp_of_systemz : systemz -> Ppx_sexp_conv_lib.Sexp.t
      type xcore = [ `xcore ]
      val bin_xcore : xcore Core_kernel.Bin_prot.Type_class.t
      val bin_read_xcore : xcore Core_kernel.Bin_prot.Read.reader
      val __bin_read_xcore__ :
        (int -> xcore) Core_kernel.Bin_prot.Read.reader
      val bin_reader_xcore : xcore Core_kernel.Bin_prot.Type_class.reader
      val bin_size_xcore : xcore Core_kernel.Bin_prot.Size.sizer
      val bin_write_xcore : xcore Core_kernel.Bin_prot.Write.writer
      val bin_writer_xcore : xcore Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_xcore : Core_kernel.Bin_prot.Shape.t
      val compare_xcore : xcore -> xcore -> int
      val all_of_xcore : xcore list
      val xcore_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> xcore
      val __xcore_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> xcore
      val sexp_of_xcore : xcore -> Ppx_sexp_conv_lib.Sexp.t
      type t =
          [ `aarch64
          | `aarch64_be
          | `armv4
          | `armv4eb
          | `armv5
          | `armv5eb
          | `armv6
          | `armv6eb
          | `armv7
          | `armv7eb
          | `hexagon
          | `mips
          | `mips64
          | `mips64el
          | `mipsel
          | `nvptx
          | `nvptx64
          | `ppc
          | `ppc64
          | `ppc64le
          | `r600
          | `sparc
          | `sparcv9
          | `systemz
          | `thumbv4
          | `thumbv4eb
          | `thumbv5
          | `thumbv5eb
          | `thumbv6
          | `thumbv6eb
          | `thumbv7
          | `thumbv7eb
          | `x86
          | `x86_64
          | `xcore ]
      val all : t list
      val __t_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> t
      val of_string : string -> Bap.Std.Arch.t option
      val addr_size : Bap.Std.Arch.t -> Bap.Std.addr_size
      val endian : Bap.Std.Arch.t -> Bap.Std.endian
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Stmt.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Stmt.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Stmt.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Stmt.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Stmt.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  type arch = Bap.Std.Arch.t
  val bin_arch : arch Core_kernel.Bin_prot.Type_class.t
  val bin_read_arch : arch Core_kernel.Bin_prot.Read.reader
  val __bin_read_arch__ : (int -> arch) Core_kernel.Bin_prot.Read.reader
  val bin_reader_arch : arch Core_kernel.Bin_prot.Type_class.reader
  val bin_size_arch : arch Core_kernel.Bin_prot.Size.sizer
  val bin_write_arch : arch Core_kernel.Bin_prot.Write.writer
  val bin_writer_arch : arch Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_arch : Core_kernel.Bin_prot.Shape.t
  val compare_arch : arch -> arch -> int
  val arch_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> arch
  val sexp_of_arch : arch -> Ppx_sexp_conv_lib.Sexp.t
  module Value :
    sig
      type t = Bap.Std.value
      type 'a tag
      module type S =
        sig
          type t
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val compare : t -> t -> int
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          val pp : Format.formatter -> Bap.Std.Value.S.t -> unit
        end
      type void
      type literal =
          (Bap.Std.Value.void, Bap.Std.Value.void, Bap.Std.Value.void)
          Core_kernel.format
      type typeid
      val bin_typeid : typeid Core_kernel.Bin_prot.Type_class.t
      val bin_read_typeid : typeid Core_kernel.Bin_prot.Read.reader
      val __bin_read_typeid__ :
        (int -> typeid) Core_kernel.Bin_prot.Read.reader
      val bin_reader_typeid : typeid Core_kernel.Bin_prot.Type_class.reader
      val bin_size_typeid : typeid Core_kernel.Bin_prot.Size.sizer
      val bin_write_typeid : typeid Core_kernel.Bin_prot.Write.writer
      val bin_writer_typeid : typeid Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_typeid : Core_kernel.Bin_prot.Shape.t
      val compare_typeid : typeid -> typeid -> int
      val typeid_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> typeid
      val sexp_of_typeid : typeid -> Ppx_sexp_conv_lib.Sexp.t
      val create : 'Bap.Std.Value.tag -> '-> Bap.Std.Value.t
      val is : 'Bap.Std.Value.tag -> Bap.Std.Value.t -> bool
      val get : 'Bap.Std.Value.tag -> Bap.Std.Value.t -> 'a option
      val get_exn : 'Bap.Std.Value.tag -> Bap.Std.Value.t -> 'a
      val tagname : Bap.Std.Value.t -> string
      val typeid : Bap.Std.Value.t -> Bap.Std.Value.typeid
      module Tag :
        sig
          type 'a t = 'Bap.Std.Value.tag
          val register :
            name:Bap.Std.Value.literal ->
            uuid:Bap.Std.Value.literal ->
            (module Bap.Std.Value.S with type t = 'a) -> 'Bap.Std.Value.tag
          val name : 'Bap.Std.Value.Tag.t -> string
          val same : 'Bap.Std.Value.Tag.t -> 'Bap.Std.Value.Tag.t -> bool
          val same_witness :
            'Bap.Std.Value.Tag.t ->
            'Bap.Std.Value.Tag.t ->
            ('a, 'b) Core_kernel.Type_equal.t option
          val same_witness_exn :
            'Bap.Std.Value.Tag.t ->
            'Bap.Std.Value.Tag.t -> ('a, 'b) Core_kernel.Type_equal.t
          val typeid : 'Bap.Std.Value.Tag.t -> Bap.Std.Value.typeid
        end
      module Match :
        sig
          type 'a t
          val switch : Bap.Std.value -> 'Bap.Std.Value.Match.t -> 's
          val select : 'Bap.Std.Value.Match.t -> Bap.Std.value -> 's
          val case :
            'Bap.Std.Value.tag ->
            ('-> 's) ->
            'Bap.Std.Value.Match.t -> 'Bap.Std.Value.Match.t
          val default : (unit -> 's) -> 'Bap.Std.Value.Match.t
        end
      module Typeid :
        sig
          type t = typeid
          val bin_t : t Bin_prot.Type_class.t
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ :
            (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_shape_t : Bin_prot.Shape.t
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          val of_string : Trie.String.Suffix.key -> t
          val to_string : t -> Trie.String.Suffix.key
          val pp : Base__.Formatter.t -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = typeid
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (typeid, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : typeid -> '-> 'a t
                  val of_alist :
                    (typeid * 'a) list ->
                    [ `Duplicate_key of typeid | `Ok of 'a t ]
                  val of_alist_or_error :
                    (typeid * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (typeid * 'a) list -> 'a t
                  val of_alist_multi : (typeid * 'a) list -> 'a list t
                  val of_alist_fold :
                    (typeid * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (typeid * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (typeid * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (typeid * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> typeid * 'a) -> 'a t
                  val of_increasing_sequence :
                    (typeid * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:typeid -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of typeid | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (typeid, 'a) Arch.Table.hashtbl -> 'a t
                  val gen :
                    typeid Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:typeid ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:typeid -> data:'-> 'a t
                  val set : 'a t -> key:typeid -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:typeid -> data:'-> 'a list t
                  val remove_multi : 'a list t -> typeid -> 'a list t
                  val find_multi : 'a list t -> typeid -> 'a list
                  val change :
                    'a t -> typeid -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> typeid -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> typeid -> 'a option
                  val find_exn : 'a t -> typeid -> 'a
                  val remove : 'a t -> typeid -> 'a t
                  val mem : 'a t -> typeid -> bool
                  val iter_keys : 'a t -> f:(typeid -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:typeid -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:typeid ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:typeid -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:typeid ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(typeid -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:typeid -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:typeid -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:typeid -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:typeid -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> typeid list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (typeid * 'a) list
                  val validate :
                    name:(typeid -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:typeid ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (typeid, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (typeid * 'a) option
                  val min_elt_exn : 'a t -> typeid * 'a
                  val max_elt : 'a t -> (typeid * 'a) option
                  val max_elt_exn : 'a t -> typeid * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:typeid -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:typeid -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:typeid -> data:'-> bool) -> int
                  val split :
                    'a t -> typeid -> 'a t * (typeid * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:typeid Base__.Maybe_bound.t ->
                    upper_bound:typeid Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:typeid ->
                    max:typeid ->
                    init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:typeid -> max:typeid -> (typeid * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> typeid -> (typeid * 'a) option
                  val nth : 'a t -> int -> (typeid * 'a) option
                  val nth_exn : 'a t -> int -> typeid * 'a
                  val rank : 'a t -> typeid -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:typeid ->
                    ?keys_less_or_equal_to:typeid ->
                    'a t -> (typeid * 'a) Base__.Sequence.t
                  val obs :
                    typeid Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    typeid Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> typeid
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (typeid, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : typeid -> '-> 'a t
              val of_alist :
                (typeid * 'a) list ->
                [ `Duplicate_key of typeid | `Ok of 'a t ]
              val of_alist_or_error :
                (typeid * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (typeid * 'a) list -> 'a t
              val of_alist_multi : (typeid * 'a) list -> 'a list t
              val of_alist_fold :
                (typeid * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (typeid * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (typeid * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (typeid * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> typeid * 'a) -> 'a t
              val of_increasing_sequence :
                (typeid * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:typeid -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of typeid | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (typeid, 'a) Arch.Table.hashtbl -> 'a t
              val gen :
                typeid Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:typeid -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:typeid -> data:'-> 'a t
              val set : 'a t -> key:typeid -> data:'-> 'a t
              val add_multi : 'a list t -> key:typeid -> data:'-> 'a list t
              val remove_multi : 'a list t -> typeid -> 'a list t
              val find_multi : 'a list t -> typeid -> 'a list
              val change :
                'a t -> typeid -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> typeid -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> typeid -> 'a option
              val find_exn : 'a t -> typeid -> 'a
              val remove : 'a t -> typeid -> 'a t
              val mem : 'a t -> typeid -> bool
              val iter_keys : 'a t -> f:(typeid -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:typeid -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:typeid ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:typeid -> data:'-> 'b) -> 'b t
              val fold :
                'a t ->
                init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t ->
                init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:typeid ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(typeid -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:typeid -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:typeid -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:typeid -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:typeid -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> typeid list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (typeid * 'a) list
              val validate :
                name:(typeid -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:typeid ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (typeid, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (typeid * 'a) option
              val min_elt_exn : 'a t -> typeid * 'a
              val max_elt : 'a t -> (typeid * 'a) option
              val max_elt_exn : 'a t -> typeid * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli :
                'a t -> f:(key:typeid -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:typeid -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:typeid -> data:'-> bool) -> int
              val split :
                'a t -> typeid -> 'a t * (typeid * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:typeid Base__.Maybe_bound.t ->
                upper_bound:typeid Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:typeid ->
                max:typeid ->
                init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:typeid -> max:typeid -> (typeid * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> typeid -> (typeid * 'a) option
              val nth : 'a t -> int -> (typeid * 'a) option
              val nth_exn : 'a t -> int -> typeid * 'a
              val rank : 'a t -> typeid -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:typeid ->
                ?keys_less_or_equal_to:typeid ->
                'a t -> (typeid * 'a) Base__.Sequence.t
              val obs :
                typeid Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                typeid Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> typeid
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : typeid Bin_prot.Type_class.t
                           val bin_read_t : typeid Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> typeid)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             typeid Bin_prot.Type_class.reader
                           val bin_size_t : typeid Bin_prot.Size.sizer
                           val bin_write_t : typeid Bin_prot.Write.writer
                           val bin_writer_t :
                             typeid Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> typeid -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = typeid
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (typeid, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (typeid, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(typeid -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> typeid -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> typeid -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(typeid -> bool) -> bool
                  val for_all : t -> f:(typeid -> bool) -> bool
                  val count : t -> f:(typeid -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(typeid -> 'sum) -> 'sum
                  val find : t -> f:(typeid -> bool) -> typeid option
                  val find_map : t -> f:(typeid -> 'a option) -> 'a option
                  val to_list : t -> typeid list
                  val to_array : t -> typeid array
                  val invariants : t -> bool
                  val mem : t -> typeid -> bool
                  val add : t -> typeid -> t
                  val remove : t -> typeid -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (typeid, typeid) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       typeid ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(typeid -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of typeid * typeid
                       | `Left of typeid
                       | `Right of typeid ] -> unit) ->
                    unit
                  val filter : t -> f:(typeid -> bool) -> t
                  val partition_tf : t -> f:(typeid -> bool) -> t * t
                  val elements : t -> typeid list
                  val min_elt : t -> typeid option
                  val min_elt_exn : t -> typeid
                  val max_elt : t -> typeid option
                  val max_elt_exn : t -> typeid
                  val choose : t -> typeid option
                  val choose_exn : t -> typeid
                  val split : t -> typeid -> t * typeid option * t
                  val group_by :
                    t -> equiv:(typeid -> typeid -> bool) -> t list
                  val find_exn : t -> f:(typeid -> bool) -> typeid
                  val find_index : t -> int -> typeid option
                  val nth : t -> int -> typeid option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:typeid ->
                    ?less_or_equal_to:typeid -> t -> typeid Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:typeid ->
                    ?less_or_equal_to:typeid ->
                    t ->
                    t ->
                    (typeid, typeid)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(typeid -> 'data) ->
                    (typeid, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    typeid Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    typeid Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : typeid -> t
                  val union_list : t list -> t
                  val of_list : typeid list -> t
                  val of_array : typeid array -> t
                  val of_sorted_array : typeid array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : typeid array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> typeid) -> t
                  val stable_dedup_list : typeid list -> typeid list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> typeid) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> typeid option) -> t
                  val of_tree : t -> t
                  val of_hash_set : typeid Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (typeid, 'a) Arch.Table.hashtbl -> t
                  val of_map_keys :
                    (typeid, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    typeid Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> typeid
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (typeid, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (typeid, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(typeid -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> typeid -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> typeid -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(typeid -> bool) -> bool
              val for_all : t -> f:(typeid -> bool) -> bool
              val count : t -> f:(typeid -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(typeid -> 'sum) -> 'sum
              val find : t -> f:(typeid -> bool) -> typeid option
              val find_map : t -> f:(typeid -> 'a option) -> 'a option
              val to_list : t -> typeid list
              val to_array : t -> typeid array
              val invariants : t -> bool
              val mem : t -> typeid -> bool
              val add : t -> typeid -> t
              val remove : t -> typeid -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (typeid, typeid) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   typeid -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(typeid -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of typeid * typeid
                   | `Left of typeid
                   | `Right of typeid ] -> unit) ->
                unit
              val filter : t -> f:(typeid -> bool) -> t
              val partition_tf : t -> f:(typeid -> bool) -> t * t
              val elements : t -> typeid list
              val min_elt : t -> typeid option
              val min_elt_exn : t -> typeid
              val max_elt : t -> typeid option
              val max_elt_exn : t -> typeid
              val choose : t -> typeid option
              val choose_exn : t -> typeid
              val split : t -> typeid -> t * typeid option * t
              val group_by : t -> equiv:(typeid -> typeid -> bool) -> t list
              val find_exn : t -> f:(typeid -> bool) -> typeid
              val find_index : t -> int -> typeid option
              val nth : t -> int -> typeid option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:typeid ->
                ?less_or_equal_to:typeid -> t -> typeid Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:typeid ->
                ?less_or_equal_to:typeid ->
                t ->
                t ->
                (typeid, typeid) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(typeid -> 'data) ->
                (typeid, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                typeid Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                typeid Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : typeid -> t
              val union_list : t list -> t
              val of_list : typeid list -> t
              val of_array : typeid array -> t
              val of_sorted_array : typeid array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : typeid array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> typeid) -> t
              val stable_dedup_list : typeid list -> typeid list
              val map : ('a, 'b) Base.Set.t -> f:('-> typeid) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> typeid option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : typeid Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (typeid, 'a) Arch.Table.hashtbl -> t
              val of_map_keys :
                (typeid, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                typeid Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> typeid
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : typeid Bin_prot.Type_class.t
                           val bin_read_t : typeid Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> typeid)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             typeid Bin_prot.Type_class.reader
                           val bin_size_t : typeid Bin_prot.Size.sizer
                           val bin_write_t : typeid Bin_prot.Write.writer
                           val bin_writer_t :
                             typeid Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> typeid -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Arch.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = typeid
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> typeid -> Core_kernel__.Import.bool
              val lookup : 'a t -> typeid -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> typeid -> 'a
              val enqueue :
                'a t -> typeid -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> typeid -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> typeid -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> typeid -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (typeid * 'a) Core_kernel__.Import.option
              val keys : 'a t -> typeid Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (typeid * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> typeid * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> typeid -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> typeid -> Core_kernel__.Import.unit
              val replace : 'a t -> typeid -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> typeid -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:typeid -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t ->
                init:'-> f:('-> key:typeid -> data:'-> 'b) -> 'b
            end
        end
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.value
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Typeid.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Typeid.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Typeid.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Typeid.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Typeid.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  type 'a tag = 'Bap.Std.Value.tag
  module Dict :
    sig
      type t = Bap.Std.dict
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val compare : t -> t -> int
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val empty : Bap.Std.Dict.t
      val is_empty : Bap.Std.Dict.t -> bool
      val set : Bap.Std.Dict.t -> 'Bap.Std.tag -> '-> Bap.Std.Dict.t
      val mem : Bap.Std.Dict.t -> 'Bap.Std.tag -> bool
      val find : Bap.Std.Dict.t -> 'Bap.Std.tag -> 'a option
      val add :
        Bap.Std.Dict.t ->
        'Bap.Std.tag -> '-> [ `Duplicate | `Ok of Bap.Std.Dict.t ]
      val change :
        Bap.Std.Dict.t ->
        'Bap.Std.tag -> ('a option -> 'a option) -> Bap.Std.Dict.t
      val remove : Bap.Std.Dict.t -> 'Bap.Std.tag -> Bap.Std.Dict.t
      val to_sequence :
        Bap.Std.Dict.t -> (Bap.Std.Value.typeid * Bap.Std.value) Bap.Std.seq
      val data : Bap.Std.Dict.t -> Bap.Std.value Bap.Std.seq
      val filter :
        Bap.Std.Dict.t -> f:(Bap.Std.value -> bool) -> Bap.Std.Dict.t
    end
  type 'a vector
  module Vector :
    sig
      type 'a t = 'Bap.Std.vector
      val bin_t :
        'Core_kernel.Bin_prot.Type_class.t ->
        'a t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t :
        'Core_kernel.Bin_prot.Read.reader ->
        'a t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ :
        'Core_kernel.Bin_prot.Read.reader ->
        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t :
        'Core_kernel.Bin_prot.Type_class.reader ->
        'a t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t :
        'Core_kernel.Bin_prot.Size.sizer ->
        'a t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t :
        'Core_kernel.Bin_prot.Write.writer ->
        'a t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t :
        'Core_kernel.Bin_prot.Type_class.writer ->
        'a t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t :
        Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val t_of_sexp :
        (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t
      val sexp_of_t :
        ('-> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t
      val create : ?capacity:int -> '-> 'Bap.Std.Vector.t
      val append : 'Bap.Std.Vector.t -> '-> unit
      val nth : 'Bap.Std.Vector.t -> int -> 'a option
      val get : 'Bap.Std.Vector.t -> int -> 'a
      val set : 'Bap.Std.Vector.t -> int -> '-> unit
      val map_to_array : 'Bap.Std.Vector.t -> f:('-> 'b) -> 'b array
      val findi :
        'Bap.Std.Vector.t -> f:(int -> '-> bool) -> (int * 'a) option
      val iteri : 'Bap.Std.Vector.t -> f:(int -> '-> unit) -> unit
      val foldi :
        'Bap.Std.Vector.t -> init:'-> f:(int -> '-> '-> 'b) -> 'b
      val index :
        ?equal:('-> '-> bool) -> 'Bap.Std.Vector.t -> '-> int option
      val index_exn :
        ?equal:('-> '-> bool) -> 'Bap.Std.Vector.t -> '-> int
      val index_with :
        ?equal:('-> '-> bool) ->
        default:int -> 'Bap.Std.Vector.t -> '-> int
      val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('-> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
      val fold_result :
        'a t ->
        init:'accum ->
        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
        ('accum, 'e) Base__.Result.t
      val fold_until :
        'a t ->
        init:'accum ->
        f:('accum ->
           '-> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
        finish:('accum -> 'final) -> 'final
      val exists : 'a t -> f:('-> bool) -> bool
      val for_all : 'a t -> f:('-> bool) -> bool
      val count : 'a t -> f:('-> bool) -> int
      val sum :
        (module Base__.Commutative_group.S with type t = 'sum) ->
        'a t -> f:('-> 'sum) -> 'sum
      val find : 'a t -> f:('-> bool) -> 'a option
      val find_map : 'a t -> f:('-> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
      val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
      val pp :
        'Regular.Std.printer -> 'Bap.Std.Vector.t Regular.Std.printer
    end
  type 'a term
  val bin_term :
    'Core_kernel.Bin_prot.Type_class.t ->
    'a term Core_kernel.Bin_prot.Type_class.t
  val bin_read_term :
    'Core_kernel.Bin_prot.Read.reader ->
    'a term Core_kernel.Bin_prot.Read.reader
  val __bin_read_term__ :
    'Core_kernel.Bin_prot.Read.reader ->
    (int -> 'a term) Core_kernel.Bin_prot.Read.reader
  val bin_reader_term :
    'Core_kernel.Bin_prot.Type_class.reader ->
    'a term Core_kernel.Bin_prot.Type_class.reader
  val bin_size_term :
    'Core_kernel.Bin_prot.Size.sizer ->
    'a term Core_kernel.Bin_prot.Size.sizer
  val bin_write_term :
    'Core_kernel.Bin_prot.Write.writer ->
    'a term Core_kernel.Bin_prot.Write.writer
  val bin_writer_term :
    'Core_kernel.Bin_prot.Type_class.writer ->
    'a term Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_term :
    Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
  val compare_term : ('-> '-> int) -> 'a term -> 'a term -> int
  val term_of_sexp :
    (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a term
  val sexp_of_term :
    ('-> Ppx_sexp_conv_lib.Sexp.t) -> 'a term -> Ppx_sexp_conv_lib.Sexp.t
  type program
  val bin_program : program Core_kernel.Bin_prot.Type_class.t
  val bin_read_program : program Core_kernel.Bin_prot.Read.reader
  val __bin_read_program__ :
    (int -> program) Core_kernel.Bin_prot.Read.reader
  val bin_reader_program : program Core_kernel.Bin_prot.Type_class.reader
  val bin_size_program : program Core_kernel.Bin_prot.Size.sizer
  val bin_write_program : program Core_kernel.Bin_prot.Write.writer
  val bin_writer_program : program Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_program : Core_kernel.Bin_prot.Shape.t
  val compare_program : program -> program -> int
  val program_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> program
  val sexp_of_program : program -> Ppx_sexp_conv_lib.Sexp.t
  type sub
  val bin_sub : sub Core_kernel.Bin_prot.Type_class.t
  val bin_read_sub : sub Core_kernel.Bin_prot.Read.reader
  val __bin_read_sub__ : (int -> sub) Core_kernel.Bin_prot.Read.reader
  val bin_reader_sub : sub Core_kernel.Bin_prot.Type_class.reader
  val bin_size_sub : sub Core_kernel.Bin_prot.Size.sizer
  val bin_write_sub : sub Core_kernel.Bin_prot.Write.writer
  val bin_writer_sub : sub Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_sub : Core_kernel.Bin_prot.Shape.t
  val compare_sub : sub -> sub -> int
  val sub_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> sub
  val sexp_of_sub : sub -> Ppx_sexp_conv_lib.Sexp.t
  type arg
  val bin_arg : arg Core_kernel.Bin_prot.Type_class.t
  val bin_read_arg : arg Core_kernel.Bin_prot.Read.reader
  val __bin_read_arg__ : (int -> arg) Core_kernel.Bin_prot.Read.reader
  val bin_reader_arg : arg Core_kernel.Bin_prot.Type_class.reader
  val bin_size_arg : arg Core_kernel.Bin_prot.Size.sizer
  val bin_write_arg : arg Core_kernel.Bin_prot.Write.writer
  val bin_writer_arg : arg Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_arg : Core_kernel.Bin_prot.Shape.t
  val compare_arg : arg -> arg -> int
  val arg_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> arg
  val sexp_of_arg : arg -> Ppx_sexp_conv_lib.Sexp.t
  type blk
  val bin_blk : blk Core_kernel.Bin_prot.Type_class.t
  val bin_read_blk : blk Core_kernel.Bin_prot.Read.reader
  val __bin_read_blk__ : (int -> blk) Core_kernel.Bin_prot.Read.reader
  val bin_reader_blk : blk Core_kernel.Bin_prot.Type_class.reader
  val bin_size_blk : blk Core_kernel.Bin_prot.Size.sizer
  val bin_write_blk : blk Core_kernel.Bin_prot.Write.writer
  val bin_writer_blk : blk Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_blk : Core_kernel.Bin_prot.Shape.t
  val compare_blk : blk -> blk -> int
  val blk_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> blk
  val sexp_of_blk : blk -> Ppx_sexp_conv_lib.Sexp.t
  type phi
  val bin_phi : phi Core_kernel.Bin_prot.Type_class.t
  val bin_read_phi : phi Core_kernel.Bin_prot.Read.reader
  val __bin_read_phi__ : (int -> phi) Core_kernel.Bin_prot.Read.reader
  val bin_reader_phi : phi Core_kernel.Bin_prot.Type_class.reader
  val bin_size_phi : phi Core_kernel.Bin_prot.Size.sizer
  val bin_write_phi : phi Core_kernel.Bin_prot.Write.writer
  val bin_writer_phi : phi Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_phi : Core_kernel.Bin_prot.Shape.t
  val compare_phi : phi -> phi -> int
  val phi_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> phi
  val sexp_of_phi : phi -> Ppx_sexp_conv_lib.Sexp.t
  type def
  val bin_def : def Core_kernel.Bin_prot.Type_class.t
  val bin_read_def : def Core_kernel.Bin_prot.Read.reader
  val __bin_read_def__ : (int -> def) Core_kernel.Bin_prot.Read.reader
  val bin_reader_def : def Core_kernel.Bin_prot.Type_class.reader
  val bin_size_def : def Core_kernel.Bin_prot.Size.sizer
  val bin_write_def : def Core_kernel.Bin_prot.Write.writer
  val bin_writer_def : def Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_def : Core_kernel.Bin_prot.Shape.t
  val compare_def : def -> def -> int
  val def_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> def
  val sexp_of_def : def -> Ppx_sexp_conv_lib.Sexp.t
  type jmp
  val bin_jmp : jmp Core_kernel.Bin_prot.Type_class.t
  val bin_read_jmp : jmp Core_kernel.Bin_prot.Read.reader
  val __bin_read_jmp__ : (int -> jmp) Core_kernel.Bin_prot.Read.reader
  val bin_reader_jmp : jmp Core_kernel.Bin_prot.Type_class.reader
  val bin_size_jmp : jmp Core_kernel.Bin_prot.Size.sizer
  val bin_write_jmp : jmp Core_kernel.Bin_prot.Write.writer
  val bin_writer_jmp : jmp Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_jmp : Core_kernel.Bin_prot.Shape.t
  val compare_jmp : jmp -> jmp -> int
  val jmp_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> jmp
  val sexp_of_jmp : jmp -> Ppx_sexp_conv_lib.Sexp.t
  type nil
  val bin_nil : nil Core_kernel.Bin_prot.Type_class.t
  val bin_read_nil : nil Core_kernel.Bin_prot.Read.reader
  val __bin_read_nil__ : (int -> nil) Core_kernel.Bin_prot.Read.reader
  val bin_reader_nil : nil Core_kernel.Bin_prot.Type_class.reader
  val bin_size_nil : nil Core_kernel.Bin_prot.Size.sizer
  val bin_write_nil : nil Core_kernel.Bin_prot.Write.writer
  val bin_writer_nil : nil Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_nil : Core_kernel.Bin_prot.Shape.t
  val compare_nil : nil -> nil -> int
  val nil_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> nil
  val sexp_of_nil : nil -> Ppx_sexp_conv_lib.Sexp.t
  type tid
  val bin_tid : tid Core_kernel.Bin_prot.Type_class.t
  val bin_read_tid : tid Core_kernel.Bin_prot.Read.reader
  val __bin_read_tid__ : (int -> tid) Core_kernel.Bin_prot.Read.reader
  val bin_reader_tid : tid Core_kernel.Bin_prot.Type_class.reader
  val bin_size_tid : tid Core_kernel.Bin_prot.Size.sizer
  val bin_write_tid : tid Core_kernel.Bin_prot.Write.writer
  val bin_writer_tid : tid Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_tid : Core_kernel.Bin_prot.Shape.t
  val compare_tid : tid -> tid -> int
  val tid_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> tid
  val sexp_of_tid : tid -> Ppx_sexp_conv_lib.Sexp.t
  type call
  val bin_call : call Core_kernel.Bin_prot.Type_class.t
  val bin_read_call : call Core_kernel.Bin_prot.Read.reader
  val __bin_read_call__ : (int -> call) Core_kernel.Bin_prot.Read.reader
  val bin_reader_call : call Core_kernel.Bin_prot.Type_class.reader
  val bin_size_call : call Core_kernel.Bin_prot.Size.sizer
  val bin_write_call : call Core_kernel.Bin_prot.Write.writer
  val bin_writer_call : call Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_call : Core_kernel.Bin_prot.Shape.t
  val compare_call : call -> call -> int
  val call_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> call
  val sexp_of_call : call -> Ppx_sexp_conv_lib.Sexp.t
  type label = Direct of Bap.Std.tid | Indirect of Bap.Std.exp
  val bin_label : label Core_kernel.Bin_prot.Type_class.t
  val bin_read_label : label Core_kernel.Bin_prot.Read.reader
  val __bin_read_label__ : (int -> label) Core_kernel.Bin_prot.Read.reader
  val bin_reader_label : label Core_kernel.Bin_prot.Type_class.reader
  val bin_size_label : label Core_kernel.Bin_prot.Size.sizer
  val bin_write_label : label Core_kernel.Bin_prot.Write.writer
  val bin_writer_label : label Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_label : Core_kernel.Bin_prot.Shape.t
  val compare_label : label -> label -> int
  val label_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> label
  val sexp_of_label : label -> Ppx_sexp_conv_lib.Sexp.t
  type jmp_kind =
      Call of Bap.Std.call
    | Goto of Bap.Std.label
    | Ret of Bap.Std.label
    | Int of int * Bap.Std.tid
  val bin_jmp_kind : jmp_kind Core_kernel.Bin_prot.Type_class.t
  val bin_read_jmp_kind : jmp_kind Core_kernel.Bin_prot.Read.reader
  val __bin_read_jmp_kind__ :
    (int -> jmp_kind) Core_kernel.Bin_prot.Read.reader
  val bin_reader_jmp_kind : jmp_kind Core_kernel.Bin_prot.Type_class.reader
  val bin_size_jmp_kind : jmp_kind Core_kernel.Bin_prot.Size.sizer
  val bin_write_jmp_kind : jmp_kind Core_kernel.Bin_prot.Write.writer
  val bin_writer_jmp_kind : jmp_kind Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_jmp_kind : Core_kernel.Bin_prot.Shape.t
  val compare_jmp_kind : jmp_kind -> jmp_kind -> int
  val jmp_kind_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> jmp_kind
  val sexp_of_jmp_kind : jmp_kind -> Ppx_sexp_conv_lib.Sexp.t
  type intent = In | Out | Both
  val bin_intent : intent Core_kernel.Bin_prot.Type_class.t
  val bin_read_intent : intent Core_kernel.Bin_prot.Read.reader
  val __bin_read_intent__ : (int -> intent) Core_kernel.Bin_prot.Read.reader
  val bin_reader_intent : intent Core_kernel.Bin_prot.Type_class.reader
  val bin_size_intent : intent Core_kernel.Bin_prot.Size.sizer
  val bin_write_intent : intent Core_kernel.Bin_prot.Write.writer
  val bin_writer_intent : intent Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_intent : Core_kernel.Bin_prot.Shape.t
  val compare_intent : intent -> intent -> int
  val intent_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> intent
  val sexp_of_intent : intent -> Ppx_sexp_conv_lib.Sexp.t
  type ('a, 'b) cls
  val program_t : (Bap.Std.nil, Bap.Std.program) Bap.Std.cls
  val sub_t : (Bap.Std.program, Bap.Std.sub) Bap.Std.cls
  val arg_t : (Bap.Std.sub, Bap.Std.arg) Bap.Std.cls
  val blk_t : (Bap.Std.sub, Bap.Std.blk) Bap.Std.cls
  val phi_t : (Bap.Std.blk, Bap.Std.phi) Bap.Std.cls
  val def_t : (Bap.Std.blk, Bap.Std.def) Bap.Std.cls
  val jmp_t : (Bap.Std.blk, Bap.Std.jmp) Bap.Std.cls
  module Biri :
    sig
      class context :
        ?main:Bap.Std.sub Bap.Std.term ->
        Bap.Std.program Bap.Std.term ->
        object ('a)
          method bindings : (Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
          method create_storage :
            Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
          method create_undefined : 'a * Bap.Std.Bil.result
          method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
          method enter_term : Bap.Std.tid -> 'a
          method lookup : Bap.Std.var -> Bap.Std.Bil.result option
          method main : Bap.Std.sub Bap.Std.term option
          method next : Bap.Std.tid option
          method program : Bap.Std.program Bap.Std.term
          method set_next : Bap.Std.tid option -> 'a
          method trace : Bap.Std.tid list
          method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
        end
      module type S =
        sig
          type ('a, 'e) state
          type 'a u = (unit, 'a) Bap.Std.Biri.S.state
          type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Biri.S.state
          module Expi :
            sig
              type ('a, 'e) state = ('a, 'e) state
              type 'a u = (unit, 'a) state
              type 'a r = (Bil.result, 'a) state
              module M : sig type ('a, 'e) t = ('a, 'e) state end
              module Eval :
                sig
                  class type ['a, 'r] semantics =
                    ['a, 'r] Eval.T2(M).semantics
                  class type virtual ['a, 'r, 's] domain =
                    ['a, 'r, 's] Eval.T2(M).domain
                  class type virtual ['a, 'r, 's] eff =
                    ['a, 'r, 's] Eval.T2(M).eff
                  class virtual ['a, 'r, 's] t :
                    object
                      method division_by_zero : unit -> ('r, 'a) state
                      method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                      method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                      method eval_concat : exp -> exp -> ('r, 'a) M.t
                      method eval_exp : exp -> ('r, 'a) M.t
                      method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                      method eval_int : word -> ('r, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                      method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                      method eval_load :
                        mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                      method eval_unop : unop -> exp -> ('r, 'a) M.t
                      method eval_var : var -> ('r, 'a) M.t
                      method virtual load : '-> addr -> ('r, 'a) M.t
                      method virtual lookup : var -> ('r, 'a) M.t
                      method private virtual storage_of_value :
                        '-> ('s option, 'a) M.t
                      method virtual store :
                        '-> addr -> word -> ('r, 'a) M.t
                      method type_error : type_error -> ('r, 'a) state
                      method private virtual undefined : ('r, 'a) M.t
                      method virtual update : var -> '-> (unit, 'a) M.t
                      method private virtual value_of_word :
                        word -> ('r, 'a) M.t
                      method private virtual word_of_value :
                        '-> (word option, 'a) M.t
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Expi.context
                  method division_by_zero : unit -> 'a r
                  method empty : Bil.storage
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method load : Bil.storage -> addr -> 'a r
                  method lookup : var -> 'a r
                  method store : Bil.storage -> addr -> word -> 'a r
                  method type_error : type_error -> 'a r
                  method undefined_addr : addr -> 'a r
                  method undefined_var : var -> 'a r
                  method update : var -> Bil.result -> 'a u
                end
            end
          class ['a] t :
            object
              constraint 'a = #Bap.Std.Biri.context
              method division_by_zero : unit -> 'Expi.r
              method empty : Bil.storage
              method enter_term :
                ('p, 't) Bap.Std.cls ->
                'Bap.Std.term -> 'Bap.Std.Biri.S.u
              method eval :
                ('p, 't) Bap.Std.cls ->
                'Bap.Std.term -> 'Bap.Std.Biri.S.u
              method eval_arg :
                Bap.Std.arg Bap.Std.term -> 'Bap.Std.Biri.S.u
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_blk :
                Bap.Std.blk Bap.Std.term -> 'Bap.Std.Biri.S.u
              method eval_call : Bap.Std.call -> 'Bap.Std.Biri.S.u
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_def :
                Bap.Std.def Bap.Std.term -> 'Bap.Std.Biri.S.u
              method eval_direct : Bap.Std.tid -> 'Bap.Std.Biri.S.u
              method eval_exn : int -> Bap.Std.tid -> 'Bap.Std.Biri.S.u
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_goto : Bap.Std.label -> 'Bap.Std.Biri.S.u
              method eval_indirect : Bap.Std.exp -> 'Bap.Std.Biri.S.u
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_jmp :
                Bap.Std.jmp Bap.Std.term -> 'Bap.Std.Biri.S.u
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_phi :
                Bap.Std.phi Bap.Std.term -> 'Bap.Std.Biri.S.u
              method eval_ret : Bap.Std.label -> 'Bap.Std.Biri.S.u
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_sub :
                Bap.Std.sub Bap.Std.term -> 'Bap.Std.Biri.S.u
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method leave_term :
                ('p, 't) Bap.Std.cls ->
                'Bap.Std.term -> 'Bap.Std.Biri.S.u
              method load : Bil.storage -> addr -> 'Expi.r
              method lookup : var -> 'Expi.r
              method store : Bil.storage -> addr -> word -> 'Expi.r
              method type_error : type_error -> 'Expi.r
              method undefined_addr : addr -> 'Expi.r
              method undefined_var : var -> 'Expi.r
              method update : var -> Bil.result -> 'Expi.u
            end
        end
      module Make :
        functor (M : Monads.Std.Monad.State.S2->
          sig
            type ('a, 'e) state = ('a, 'e) M.t
            type 'a u = (unit, 'a) state
            type 'a r = (Bil.result, 'a) state
            module Expi :
              sig
                type ('a, 'e) state = ('a, 'e) M.t
                type 'a u = (unit, 'a) state
                type 'a r = (Bil.result, 'a) state
                module M : sig type ('a, 'e) t = ('a, 'e) state end
                module Eval :
                  sig
                    class type ['a, 'r] semantics =
                      ['a, 'r] Eval.T2(M).semantics
                    class type virtual ['a, 'r, 's] domain =
                      ['a, 'r, 's] Eval.T2(M).domain
                    class type virtual ['a, 'r, 's] eff =
                      ['a, 'r, 's] Eval.T2(M).eff
                    class virtual ['a, 'r, 's] t :
                      object
                        method division_by_zero : unit -> ('r, 'a) state
                        method eval_binop :
                          binop -> exp -> exp -> ('r, 'a) M.t
                        method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                        method eval_concat : exp -> exp -> ('r, 'a) M.t
                        method eval_exp : exp -> ('r, 'a) M.t
                        method eval_extract :
                          int -> int -> exp -> ('r, 'a) M.t
                        method eval_int : word -> ('r, 'a) M.t
                        method eval_ite :
                          cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                        method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                        method eval_load :
                          mem:exp ->
                          addr:exp -> endian -> size -> ('r, 'a) M.t
                        method eval_store :
                          mem:exp ->
                          addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                        method eval_unknown :
                          Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                        method eval_unop : unop -> exp -> ('r, 'a) M.t
                        method eval_var : var -> ('r, 'a) M.t
                        method virtual load : '-> addr -> ('r, 'a) M.t
                        method virtual lookup : var -> ('r, 'a) M.t
                        method private virtual storage_of_value :
                          '-> ('s option, 'a) M.t
                        method virtual store :
                          '-> addr -> word -> ('r, 'a) M.t
                        method type_error : type_error -> ('r, 'a) state
                        method private virtual undefined : ('r, 'a) M.t
                        method virtual update : var -> '-> (unit, 'a) M.t
                        method private virtual value_of_word :
                          word -> ('r, 'a) M.t
                        method private virtual word_of_value :
                          '-> (word option, 'a) M.t
                      end
                  end
                class ['a] t :
                  object
                    constraint 'a = #Expi.context
                    method division_by_zero : unit -> 'a r
                    method empty : Bil.storage
                    method eval_binop :
                      binop -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_cast :
                      cast -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                    method eval_exp : exp -> (Bil.result, 'a) M.t
                    method eval_extract :
                      int -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_int : word -> (Bil.result, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                    method eval_let :
                      var -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_load :
                      mem:exp ->
                      addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_store :
                      mem:exp ->
                      addr:exp ->
                      exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                    method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                    method eval_var : var -> (Bil.result, 'a) M.t
                    method load : Bil.storage -> addr -> 'a r
                    method lookup : var -> 'a r
                    method store : Bil.storage -> addr -> word -> 'a r
                    method type_error : type_error -> 'a r
                    method undefined_addr : addr -> 'a r
                    method undefined_var : var -> 'a r
                    method update : var -> Bil.result -> 'a u
                  end
              end
            class ['a] t :
              object
                constraint 'a = #context
                method division_by_zero : unit -> 'Expi.r
                method empty : Bil.storage
                method enter_term : ('p, 't) cls -> 't term -> 'a u
                method eval : ('p, 't) cls -> 't term -> 'a u
                method eval_arg : arg term -> 'a u
                method eval_binop :
                  binop -> exp -> exp -> (Bil.result, 'a) M.t
                method eval_blk : blk term -> 'a u
                method eval_call : call -> 'a u
                method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
                method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                method eval_def : def term -> 'a u
                method eval_direct : tid -> 'a u
                method eval_exn : int -> tid -> 'a u
                method eval_exp : exp -> (Bil.result, 'a) M.t
                method eval_extract :
                  int -> int -> exp -> (Bil.result, 'a) M.t
                method eval_goto : label -> 'a u
                method eval_indirect : exp -> 'a u
                method eval_int : word -> (Bil.result, 'a) M.t
                method eval_ite :
                  cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                method eval_jmp : jmp term -> 'a u
                method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                method eval_load :
                  mem:exp ->
                  addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                method eval_phi : phi term -> 'a u
                method eval_ret : label -> 'a u
                method eval_store :
                  mem:exp ->
                  addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                method eval_sub : sub term -> 'a u
                method eval_unknown :
                  Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                method eval_var : var -> (Bil.result, 'a) M.t
                method leave_term : ('p, 't) cls -> 't term -> 'a u
                method load : Bil.storage -> addr -> 'Expi.r
                method lookup : var -> 'Expi.r
                method store : Bil.storage -> addr -> word -> 'Expi.r
                method type_error : type_error -> 'Expi.r
                method undefined_addr : addr -> 'Expi.r
                method undefined_var : var -> 'Expi.r
                method update : var -> Bil.result -> 'Expi.u
              end
          end
      type ('a, 'e) state = ('a, 'e) Bili.state
      type 'a u = (unit, 'a) state
      type 'a r = (Bil.result, 'a) state
      module Expi :
        sig
          type ('a, 'e) state = ('a, 'e) Bili.state
          type 'a u = (unit, 'a) state
          type 'a r = (Bil.result, 'a) state
          module M : sig type ('a, 'e) t = ('a, 'e) state end
          module Eval :
            sig
              class type ['a, 'r] semantics = ['a, 'r] Eval.T2(M).semantics
              class type virtual ['a, 'r, 's] domain =
                ['a, 'r, 's] Eval.T2(M).domain
              class type virtual ['a, 'r, 's] eff =
                ['a, 'r, 's] Eval.T2(M).eff
              class virtual ['a, 'r, 's] t :
                object
                  method division_by_zero : unit -> ('r, 'a) state
                  method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                  method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                  method eval_concat : exp -> exp -> ('r, 'a) M.t
                  method eval_exp : exp -> ('r, 'a) M.t
                  method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                  method eval_int : word -> ('r, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                  method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                  method eval_load :
                    mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                  method eval_unop : unop -> exp -> ('r, 'a) M.t
                  method eval_var : var -> ('r, 'a) M.t
                  method virtual load : '-> addr -> ('r, 'a) M.t
                  method virtual lookup : var -> ('r, 'a) M.t
                  method private virtual storage_of_value :
                    '-> ('s option, 'a) M.t
                  method virtual store : '-> addr -> word -> ('r, 'a) M.t
                  method type_error : type_error -> ('r, 'a) state
                  method private virtual undefined : ('r, 'a) M.t
                  method virtual update : var -> '-> (unit, 'a) M.t
                  method private virtual value_of_word : word -> ('r, 'a) M.t
                  method private virtual word_of_value :
                    '-> (word option, 'a) M.t
                end
            end
          class ['a] t :
            object
              constraint 'a = #Expi.context
              method division_by_zero : unit -> 'a r
              method empty : Bil.storage
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method load : Bil.storage -> addr -> 'a r
              method lookup : var -> 'a r
              method store : Bil.storage -> addr -> word -> 'a r
              method type_error : type_error -> 'a r
              method undefined_addr : addr -> 'a r
              method undefined_var : var -> 'a r
              method update : var -> Bil.result -> 'a u
            end
        end
      class ['a] t :
        object
          constraint 'a = #context
          method division_by_zero : unit -> 'Expi.r
          method empty : Bil.storage
          method enter_term : ('p, 't) cls -> 't term -> 'a u
          method eval : ('p, 't) cls -> 't term -> 'a u
          method eval_arg : arg term -> 'a u
          method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_blk : blk term -> 'a u
          method eval_call : call -> 'a u
          method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
          method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
          method eval_def : def term -> 'a u
          method eval_direct : tid -> 'a u
          method eval_exn : int -> tid -> 'a u
          method eval_exp : exp -> (Bil.result, 'a) M.t
          method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
          method eval_goto : label -> 'a u
          method eval_indirect : exp -> 'a u
          method eval_int : word -> (Bil.result, 'a) M.t
          method eval_ite :
            cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
          method eval_jmp : jmp term -> 'a u
          method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_load :
            mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_phi : phi term -> 'a u
          method eval_ret : label -> 'a u
          method eval_store :
            mem:exp ->
            addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_sub : sub term -> 'a u
          method eval_unknown :
            Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
          method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
          method eval_var : var -> (Bil.result, 'a) M.t
          method leave_term : ('p, 't) cls -> 't term -> 'a u
          method load : Bil.storage -> addr -> 'Expi.r
          method lookup : var -> 'Expi.r
          method store : Bil.storage -> addr -> word -> 'Expi.r
          method type_error : type_error -> 'Expi.r
          method undefined_addr : addr -> 'Expi.r
          method undefined_var : var -> 'Expi.r
          method update : var -> Bil.result -> 'Expi.u
        end
    end
  class ['a] biri :
    object
      constraint 'a = #Bap.Std.Biri.context
      method division_by_zero : unit -> 'Biri.Expi.r
      method empty : Bil.storage
      method enter_term : ('p, 't) cls -> 't term -> 'Biri.u
      method eval : ('p, 't) cls -> 't term -> 'Biri.u
      method eval_arg : arg term -> 'Biri.u
      method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
      method eval_blk : blk term -> 'Biri.u
      method eval_call : call -> 'Biri.u
      method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
      method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
      method eval_def : def term -> 'Biri.u
      method eval_direct : tid -> 'Biri.u
      method eval_exn : int -> tid -> 'Biri.u
      method eval_exp : exp -> (Bil.result, 'a) M.t
      method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
      method eval_goto : label -> 'Biri.u
      method eval_indirect : exp -> 'Biri.u
      method eval_int : word -> (Bil.result, 'a) M.t
      method eval_ite : cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
      method eval_jmp : jmp term -> 'Biri.u
      method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
      method eval_load :
        mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
      method eval_phi : phi term -> 'Biri.u
      method eval_ret : label -> 'Biri.u
      method eval_store :
        mem:exp -> addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
      method eval_sub : sub term -> 'Biri.u
      method eval_unknown :
        Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
      method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
      method eval_var : var -> (Bil.result, 'a) M.t
      method leave_term : ('p, 't) cls -> 't term -> 'Biri.u
      method load : Bil.storage -> addr -> 'Biri.Expi.r
      method lookup : var -> 'Biri.Expi.r
      method store : Bil.storage -> addr -> word -> 'Biri.Expi.r
      method type_error : type_error -> 'Biri.Expi.r
      method undefined_addr : addr -> 'Biri.Expi.r
      method undefined_var : var -> 'Biri.Expi.r
      method update : var -> Bil.result -> 'Biri.Expi.u
    end
  type color =
      [ `black
      | `blue
      | `cyan
      | `gray
      | `green
      | `magenta
      | `red
      | `white
      | `yellow ]
  val bin_color : color Core_kernel.Bin_prot.Type_class.t
  val bin_read_color : color Core_kernel.Bin_prot.Read.reader
  val __bin_read_color__ : (int -> color) Core_kernel.Bin_prot.Read.reader
  val bin_reader_color : color Core_kernel.Bin_prot.Type_class.reader
  val bin_size_color : color Core_kernel.Bin_prot.Size.sizer
  val bin_write_color : color Core_kernel.Bin_prot.Write.writer
  val bin_writer_color : color Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_color : Core_kernel.Bin_prot.Shape.t
  val compare_color : color -> color -> int
  val color_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> color
  val __color_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> color
  val sexp_of_color : color -> Ppx_sexp_conv_lib.Sexp.t
  val color : Bap.Std.color Bap.Std.tag
  val foreground : Bap.Std.color Bap.Std.tag
  val background : Bap.Std.color Bap.Std.tag
  val comment : string Bap.Std.tag
  val python : string Bap.Std.tag
  val shell : string Bap.Std.tag
  val mark : unit Bap.Std.tag
  val weight : float Bap.Std.tag
  val address : Bap.Std.addr Bap.Std.tag
  val filename : string Bap.Std.tag
  type image
  type mem
  val sexp_of_mem : mem -> Ppx_sexp_conv_lib.Sexp.t
  type 'a table
  val sexp_of_table :
    ('-> Ppx_sexp_conv_lib.Sexp.t) -> 'a table -> Ppx_sexp_conv_lib.Sexp.t
  type 'a memmap
  val sexp_of_memmap :
    ('-> Ppx_sexp_conv_lib.Sexp.t) -> 'a memmap -> Ppx_sexp_conv_lib.Sexp.t
  module type Memory_iterators =
    sig
      type t
      type 'a m
      val fold :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        init:'->
        f:(Bap.Std.word -> '-> 'Bap.Std.Memory_iterators.m) ->
        'Bap.Std.Memory_iterators.m
      val iter :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        f:(Bap.Std.word -> unit Bap.Std.Memory_iterators.m) ->
        unit Bap.Std.Memory_iterators.m
      val foldi :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        init:'->
        f:(Bap.Std.addr ->
           Bap.Std.word -> '-> 'Bap.Std.Memory_iterators.m) ->
        'Bap.Std.Memory_iterators.m
      val iteri :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        f:(Bap.Std.addr -> Bap.Std.word -> unit Bap.Std.Memory_iterators.m) ->
        unit Bap.Std.Memory_iterators.m
      val exists :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        f:(Bap.Std.addr -> Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
        bool Bap.Std.Memory_iterators.m
      val for_all :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        f:(Bap.Std.addr -> Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
        bool Bap.Std.Memory_iterators.m
      val count :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        f:(Bap.Std.addr -> Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
        int Bap.Std.Memory_iterators.m
      val find_if :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        f:(Bap.Std.addr -> Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
        Bap.Std.word option Bap.Std.Memory_iterators.m
      val find_map :
        ?word_size:Bap.Std.size ->
        Bap.Std.Memory_iterators.t ->
        f:(Bap.Std.addr ->
           Bap.Std.word -> 'a option Bap.Std.Memory_iterators.m) ->
        'a option Bap.Std.Memory_iterators.m
    end
  module Memory :
    sig
      type t = Bap.Std.mem
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val create :
        ?pos:int ->
        ?len:int ->
        Bap.Std.endian ->
        Bap.Std.addr ->
        Core_kernel.Bigstring.t -> Bap.Std.Memory.t Core_kernel.Or_error.t
      val of_file :
        Bap.Std.endian ->
        Bap.Std.addr -> string -> Bap.Std.Memory.t Core_kernel.Or_error.t
      val view :
        ?word_size:Bap.Std.size ->
        ?from:Bap.Std.addr ->
        ?words:int ->
        Bap.Std.Memory.t -> Bap.Std.Memory.t Core_kernel.Or_error.t
      val range :
        Bap.Std.Memory.t ->
        Bap.Std.addr ->
        Bap.Std.addr -> Bap.Std.Memory.t Core_kernel.Or_error.t
      val merge :
        Bap.Std.Memory.t ->
        Bap.Std.Memory.t -> Bap.Std.Memory.t Core_kernel.Or_error.t
      val first_byte : Bap.Std.Memory.t -> Bap.Std.Memory.t
      val last_byte : Bap.Std.Memory.t -> Bap.Std.Memory.t
      val endian : Bap.Std.Memory.t -> Bap.Std.endian
      val get :
        ?disp:int ->
        ?index:int ->
        ?scale:Bap.Std.size ->
        ?addr:Bap.Std.addr ->
        Bap.Std.Memory.t -> Bap.Std.word Core_kernel.Or_error.t
      val ( ^ ) :
        Bap.Std.Memory.t ->
        Bap.Std.addr -> Bap.Std.word Core_kernel.Or_error.t
      val ( ^! ) : Bap.Std.Memory.t -> Bap.Std.addr -> Bap.Std.word
      val max_addr : Bap.Std.Memory.t -> Bap.Std.addr
      val min_addr : Bap.Std.Memory.t -> Bap.Std.addr
      val length : Bap.Std.Memory.t -> int
      val contains : Bap.Std.Memory.t -> Bap.Std.addr -> bool
      val compare_with :
        Bap.Std.Memory.t ->
        Bap.Std.addr -> [ `addr_is_above | `addr_is_below | `addr_is_inside ]
      module Input :
        sig
          type 'a reader =
              Bap.Std.Memory.t ->
              pos_ref:Bap.Std.addr Core_kernel.ref ->
              'Core_kernel.Or_error.t
          val word :
            word_size:Bap.Std.size ->
            Bap.Std.word Bap.Std.Memory.Input.reader
          val int8 : Bap.Std.word Bap.Std.Memory.Input.reader
          val uint8 : Bap.Std.word Bap.Std.Memory.Input.reader
          val int16 : Bap.Std.word Bap.Std.Memory.Input.reader
          val uint16 : Bap.Std.word Bap.Std.Memory.Input.reader
          val int32 : Bap.Std.word Bap.Std.Memory.Input.reader
          val int64 : Bap.Std.word Bap.Std.Memory.Input.reader
        end
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val hexdump : Bap.Std.Memory.t -> string
      type 'a m = 'a
      val fold :
        ?word_size:size -> t -> init:'-> f:(word -> '-> 'b) -> 'b
      val iter : ?word_size:size -> t -> f:(word -> unit) -> unit
      val foldi :
        ?word_size:size -> t -> init:'-> f:(addr -> word -> '-> 'b) -> 'b
      val iteri : ?word_size:size -> t -> f:(addr -> word -> unit) -> unit
      val exists : ?word_size:size -> t -> f:(addr -> word -> bool) -> bool
      val for_all : ?word_size:size -> t -> f:(addr -> word -> bool) -> bool
      val count : ?word_size:size -> t -> f:(addr -> word -> bool) -> int
      val find_if :
        ?word_size:size -> t -> f:(addr -> word -> bool) -> word option
      val find_map :
        ?word_size:size -> t -> f:(addr -> word -> 'a option) -> 'a option
      module With_error :
        sig
          type 'a m = 'Core_kernel.Or_error.t
          val fold :
            ?word_size:size -> t -> init:'-> f:(word -> '-> 'b m) -> 'b m
          val iter : ?word_size:size -> t -> f:(word -> unit m) -> unit m
          val foldi :
            ?word_size:size ->
            t -> init:'-> f:(addr -> word -> '-> 'b m) -> 'b m
          val iteri :
            ?word_size:size -> t -> f:(addr -> word -> unit m) -> unit m
          val exists :
            ?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
          val for_all :
            ?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
          val count :
            ?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
          val find_if :
            ?word_size:size ->
            t -> f:(addr -> word -> bool m) -> word option m
          val find_map :
            ?word_size:size ->
            t -> f:(addr -> word -> 'a option m) -> 'a option m
        end
      module Make_iterators :
        functor (M : Legacy.Monad.S->
          sig
            type 'a m = 'M.t
            val fold :
              ?word_size:size ->
              t -> init:'-> f:(word -> '-> 'b m) -> 'b m
            val iter : ?word_size:size -> t -> f:(word -> unit m) -> unit m
            val foldi :
              ?word_size:size ->
              t -> init:'-> f:(addr -> word -> '-> 'b m) -> 'b m
            val iteri :
              ?word_size:size -> t -> f:(addr -> word -> unit m) -> unit m
            val exists :
              ?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
            val for_all :
              ?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
            val count :
              ?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
            val find_if :
              ?word_size:size ->
              t -> f:(addr -> word -> bool m) -> word option m
            val find_map :
              ?word_size:size ->
              t -> f:(addr -> word -> 'a option m) -> 'a option m
          end
      val to_buffer : Bap.Std.Memory.t -> Core_kernel.Bigsubstring.t
      module Trie :
        sig
          module Stable :
            sig
              module V1 :
                sig
                  module R8 :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Bin_prot.Read.reader ->
                        'a t Core_kernel.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Bin_prot.Write.writer ->
                        'a t Core_kernel.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Bin_prot.Shape.t ->
                        Core_kernel.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      type key = Bap.Std.mem
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module R16 :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Bin_prot.Read.reader ->
                        'a t Core_kernel.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Bin_prot.Write.writer ->
                        'a t Core_kernel.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Bin_prot.Shape.t ->
                        Core_kernel.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      type key = R8.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module R32 :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Bin_prot.Read.reader ->
                        'a t Core_kernel.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Bin_prot.Write.writer ->
                        'a t Core_kernel.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Bin_prot.Shape.t ->
                        Core_kernel.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      type key = R16.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module R64 :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Bin_prot.Read.reader ->
                        'a t Core_kernel.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Bin_prot.Write.writer ->
                        'a t Core_kernel.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Bin_prot.Shape.t ->
                        Core_kernel.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      type key = R32.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                end
              module V2 :
                sig
                  module R8 :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Bin_prot.Read.reader ->
                        'a t Core_kernel.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Bin_prot.Write.writer ->
                        'a t Core_kernel.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Bin_prot.Shape.t ->
                        Core_kernel.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      type key = V1.R8.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module R16 :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Bin_prot.Read.reader ->
                        'a t Core_kernel.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Bin_prot.Write.writer ->
                        'a t Core_kernel.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Bin_prot.Shape.t ->
                        Core_kernel.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      type key = R8.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module R32 :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Bin_prot.Read.reader ->
                        'a t Core_kernel.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Bin_prot.Write.writer ->
                        'a t Core_kernel.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Bin_prot.Shape.t ->
                        Core_kernel.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      type key = R16.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module R64 :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Bin_prot.Read.reader ->
                        'a t Core_kernel.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Bin_prot.Write.writer ->
                        'a t Core_kernel.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Bin_prot.Shape.t ->
                        Core_kernel.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      type key = R32.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                end
            end
          module R8 :
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              type key = Stable.V2.R8.key
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          module R16 :
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              type key = R8.key
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          module R32 :
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              type key = R16.key
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          module R64 :
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              type key = R32.key
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
        end
    end
  module Table :
    sig
      type 'a t = 'Bap.Std.table
      val sexp_of_t :
        ('-> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t
      type 'a hashable = 'Core_kernel.Hashtbl.Hashable.t
      val empty : 'Bap.Std.Table.t
      val singleton : Bap.Std.mem -> '-> 'Bap.Std.Table.t
      val add :
        'Bap.Std.Table.t ->
        Bap.Std.mem -> '-> 'Bap.Std.Table.t Core_kernel.Or_error.t
      val remove : 'Bap.Std.Table.t -> Bap.Std.mem -> 'Bap.Std.Table.t
      val change :
        'Bap.Std.Table.t ->
        Bap.Std.mem ->
        f:((Bap.Std.mem * 'a) Bap.Std.seq ->
           [ `ignore
           | `rebind of Bap.Std.mem * 'a
           | `remove
           | `update of Bap.Std.mem * '-> 'a ]) ->
        'Bap.Std.Table.t
      val length : 'Bap.Std.Table.t -> int
      val find : 'Bap.Std.Table.t -> Bap.Std.mem -> 'a option
      val find_addr :
        'Bap.Std.Table.t -> Bap.Std.addr -> (Bap.Std.mem * 'a) option
      val intersections :
        'Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
      val fold_intersections :
        'Bap.Std.Table.t ->
        Bap.Std.mem -> init:'-> f:(Bap.Std.mem -> '-> '-> 'b) -> 'b
      val has_intersections : 'Bap.Std.Table.t -> Bap.Std.mem -> bool
      val mem : 'Bap.Std.Table.t -> Bap.Std.mem -> bool
      val next :
        'Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) option
      val prev :
        'Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) option
      val min : 'Bap.Std.Table.t -> (Bap.Std.mem * 'a) option
      val max : 'Bap.Std.Table.t -> (Bap.Std.mem * 'a) option
      type ('a, 'm) r
      val many : ('a, 'Bap.Std.seq) Bap.Std.Table.r
      val at_least_one : ('a, 'a * 'Bap.Std.seq) Bap.Std.Table.r
      val one : ('a, 'a) Bap.Std.Table.r
      val maybe_one : ('a, 'a option) Bap.Std.Table.r
      val link :
        one_to:('b, 'r) Bap.Std.Table.r ->
        'Bap.Std.Table.hashable ->
        'Bap.Std.Table.t -> 'Bap.Std.Table.t -> '-> 'r
      val rev_map :
        one_to:(Bap.Std.mem, 'r) Bap.Std.Table.r ->
        'Bap.Std.Table.hashable ->
        'Bap.Std.Table.t -> ('-> 'r) Core_kernel.Or_error.t
      type 'a ranged = ?start:Bap.Std.mem -> ?until:Bap.Std.mem -> 'a
      val exists :
        ('Bap.Std.Table.t -> f:('-> bool) -> bool) Bap.Std.Table.ranged
      val for_all :
        ('Bap.Std.Table.t -> f:('-> bool) -> bool) Bap.Std.Table.ranged
      val existsi :
        ('Bap.Std.Table.t -> f:(Bap.Std.mem -> '-> bool) -> bool)
        Bap.Std.Table.ranged
      val for_alli :
        ('Bap.Std.Table.t -> f:(Bap.Std.mem -> '-> bool) -> bool)
        Bap.Std.Table.ranged
      val count :
        ('Bap.Std.Table.t -> f:('-> bool) -> int) Bap.Std.Table.ranged
      val find_if :
        ('Bap.Std.Table.t -> f:('-> bool) -> 'a option)
        Bap.Std.Table.ranged
      val find_map :
        ('Bap.Std.Table.t -> f:('-> 'b option) -> 'b option)
        Bap.Std.Table.ranged
      val fold :
        ('Bap.Std.Table.t -> init:'-> f:('-> '-> 'b) -> 'b)
        Bap.Std.Table.ranged
      val iter :
        ('Bap.Std.Table.t -> f:('-> unit) -> unit) Bap.Std.Table.ranged
      val find_mapi :
        ('Bap.Std.Table.t ->
         f:(Bap.Std.mem -> '-> 'b option) -> 'b option)
        Bap.Std.Table.ranged
      val foldi :
        ('Bap.Std.Table.t ->
         init:'-> f:(Bap.Std.mem -> '-> '-> 'b) -> 'b)
        Bap.Std.Table.ranged
      val iteri :
        ('Bap.Std.Table.t -> f:(Bap.Std.mem -> '-> unit) -> unit)
        Bap.Std.Table.ranged
      val map :
        ('Bap.Std.Table.t -> f:('-> 'b) -> 'Bap.Std.Table.t)
        Bap.Std.Table.ranged
      val mapi :
        ('Bap.Std.Table.t ->
         f:(Bap.Std.mem -> '-> 'b) -> 'Bap.Std.Table.t)
        Bap.Std.Table.ranged
      val filter :
        ('Bap.Std.Table.t -> f:('-> bool) -> 'Bap.Std.Table.t)
        Bap.Std.Table.ranged
      val filter_map :
        ('Bap.Std.Table.t -> f:('-> 'b option) -> 'Bap.Std.Table.t)
        Bap.Std.Table.ranged
      val filteri :
        ('Bap.Std.Table.t ->
         f:(Bap.Std.mem -> '-> bool) -> 'Bap.Std.Table.t)
        Bap.Std.Table.ranged
      val filter_mapi :
        ('Bap.Std.Table.t ->
         f:(Bap.Std.mem -> '-> 'b option) -> 'Bap.Std.Table.t)
        Bap.Std.Table.ranged
      val to_sequence :
        ('Bap.Std.Table.t -> (Bap.Std.mem * 'a) Bap.Std.seq)
        Bap.Std.Table.ranged
      val regions :
        ('Bap.Std.Table.t -> Bap.Std.mem Bap.Std.seq) Bap.Std.Table.ranged
      val elements :
        ('Bap.Std.Table.t -> 'Bap.Std.seq) Bap.Std.Table.ranged
      val pp :
        'Regular.Std.printer -> 'Bap.Std.Table.t Regular.Std.printer
    end
  module Location :
    sig
      type t = { addr : Bap.Std.addr; len : int; }
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val compare : t -> t -> int
      val len : t -> int
      val addr : t -> addr
      module Fields :
        sig
          val names : Trie.String.Suffix.key list
          val len : (t, int) Fieldslib.Field.t
          val addr : (t, addr) Fieldslib.Field.t
          val fold :
            init:'acc__0 ->
            addr:('acc__0 -> (t, addr) Fieldslib.Field.t -> 'acc__1) ->
            len:('acc__1 -> (t, int) Fieldslib.Field.t -> 'acc__2) -> 'acc__2
          val make_creator :
            addr:((t, addr) Fieldslib.Field.t ->
                  'acc__0 -> ('input__ -> addr) * 'acc__1) ->
            len:((t, int) Fieldslib.Field.t ->
                 'acc__1 -> ('input__ -> int) * 'acc__2) ->
            'acc__0 -> ('input__ -> t) * 'acc__2
          val create : addr:addr -> len:int -> t
          val map :
            addr:((t, addr) Fieldslib.Field.t -> addr) ->
            len:((t, int) Fieldslib.Field.t -> int) -> t
          val iter :
            addr:((t, addr) Fieldslib.Field.t -> unit) ->
            len:((t, int) Fieldslib.Field.t -> unit) -> unit
          val for_all :
            addr:((t, addr) Fieldslib.Field.t -> bool) ->
            len:((t, int) Fieldslib.Field.t -> bool) -> bool
          val exists :
            addr:((t, addr) Fieldslib.Field.t -> bool) ->
            len:((t, int) Fieldslib.Field.t -> bool) -> bool
          val to_list :
            addr:((t, addr) Fieldslib.Field.t -> 'elem__) ->
            len:((t, int) Fieldslib.Field.t -> 'elem__) -> 'elem__ list
          val map_poly :
            ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
            'x0 list
          module Direct :
            sig
              val iter :
                t ->
                addr:((t, addr) Fieldslib.Field.t -> t -> addr -> unit) ->
                len:((t, int) Fieldslib.Field.t -> t -> int -> unit) -> unit
              val fold :
                t ->
                init:'acc__0 ->
                addr:('acc__0 ->
                      (t, addr) Fieldslib.Field.t -> t -> addr -> 'acc__1) ->
                len:('acc__1 ->
                     (t, int) Fieldslib.Field.t -> t -> int -> 'acc__2) ->
                'acc__2
              val for_all :
                t ->
                addr:((t, addr) Fieldslib.Field.t -> t -> addr -> bool) ->
                len:((t, int) Fieldslib.Field.t -> t -> int -> bool) -> bool
              val exists :
                t ->
                addr:((t, addr) Fieldslib.Field.t -> t -> addr -> bool) ->
                len:((t, int) Fieldslib.Field.t -> t -> int -> bool) -> bool
              val to_list :
                t ->
                addr:((t, addr) Fieldslib.Field.t -> t -> addr -> 'elem__) ->
                len:((t, int) Fieldslib.Field.t -> t -> int -> 'elem__) ->
                'elem__ list
              val map :
                t ->
                addr:((t, addr) Fieldslib.Field.t -> t -> addr -> addr) ->
                len:((t, int) Fieldslib.Field.t -> t -> int -> int) -> t
              val set_all_mutable_fields : t -> unit
            end
        end
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
    end
  type location = Bap.Std.Location.t
  val bin_location : location Core_kernel.Bin_prot.Type_class.t
  val bin_read_location : location Core_kernel.Bin_prot.Read.reader
  val __bin_read_location__ :
    (int -> location) Core_kernel.Bin_prot.Read.reader
  val bin_reader_location : location Core_kernel.Bin_prot.Type_class.reader
  val bin_size_location : location Core_kernel.Bin_prot.Size.sizer
  val bin_write_location : location Core_kernel.Bin_prot.Write.writer
  val bin_writer_location : location Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_location : Core_kernel.Bin_prot.Shape.t
  val compare_location : location -> location -> int
  val location_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> location
  val sexp_of_location : location -> Ppx_sexp_conv_lib.Sexp.t
  module Backend :
    sig
      type perm =
          R
        | W
        | X
        | Or of Bap.Std.Backend.perm * Bap.Std.Backend.perm
      val bin_perm : perm Core_kernel.Bin_prot.Type_class.t
      val bin_read_perm : perm Core_kernel.Bin_prot.Read.reader
      val __bin_read_perm__ : (int -> perm) Core_kernel.Bin_prot.Read.reader
      val bin_reader_perm : perm Core_kernel.Bin_prot.Type_class.reader
      val bin_size_perm : perm Core_kernel.Bin_prot.Size.sizer
      val bin_write_perm : perm Core_kernel.Bin_prot.Write.writer
      val bin_writer_perm : perm Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_perm : Core_kernel.Bin_prot.Shape.t
      val compare_perm : perm -> perm -> int
      val perm_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> perm
      val sexp_of_perm : perm -> Ppx_sexp_conv_lib.Sexp.t
      module Segment :
        sig
          type t = {
            name : string;
            perm : Bap.Std.Backend.perm;
            off : int;
            location : Bap.Std.location;
          }
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val compare : t -> t -> int
          val location : t -> location
          val off : t -> int
          val perm : t -> perm
          val name : t -> Trie.String.Suffix.key
          module Fields :
            sig
              val names : Trie.String.Suffix.key list
              val location : (t, location) Fieldslib.Field.t
              val off : (t, int) Fieldslib.Field.t
              val perm : (t, perm) Fieldslib.Field.t
              val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
              val fold :
                init:'acc__0 ->
                name:('acc__0 ->
                      (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'acc__1) ->
                perm:('acc__1 -> (t, perm) Fieldslib.Field.t -> 'acc__2) ->
                off:('acc__2 -> (t, int) Fieldslib.Field.t -> 'acc__3) ->
                location:('acc__3 ->
                          (t, location) Fieldslib.Field.t -> 'acc__4) ->
                'acc__4
              val make_creator :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'acc__0 ->
                      ('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
                perm:((t, perm) Fieldslib.Field.t ->
                      'acc__1 -> ('input__ -> perm) * 'acc__2) ->
                off:((t, int) Fieldslib.Field.t ->
                     'acc__2 -> ('input__ -> int) * 'acc__3) ->
                location:((t, location) Fieldslib.Field.t ->
                          'acc__3 -> ('input__ -> location) * 'acc__4) ->
                'acc__0 -> ('input__ -> t) * 'acc__4
              val create :
                name:Trie.String.Suffix.key ->
                perm:perm -> off:int -> location:location -> t
              val map :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      Trie.String.Suffix.key) ->
                perm:((t, perm) Fieldslib.Field.t -> perm) ->
                off:((t, int) Fieldslib.Field.t -> int) ->
                location:((t, location) Fieldslib.Field.t -> location) -> t
              val iter :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> unit) ->
                perm:((t, perm) Fieldslib.Field.t -> unit) ->
                off:((t, int) Fieldslib.Field.t -> unit) ->
                location:((t, location) Fieldslib.Field.t -> unit) -> unit
              val for_all :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> bool) ->
                perm:((t, perm) Fieldslib.Field.t -> bool) ->
                off:((t, int) Fieldslib.Field.t -> bool) ->
                location:((t, location) Fieldslib.Field.t -> bool) -> bool
              val exists :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> bool) ->
                perm:((t, perm) Fieldslib.Field.t -> bool) ->
                off:((t, int) Fieldslib.Field.t -> bool) ->
                location:((t, location) Fieldslib.Field.t -> bool) -> bool
              val to_list :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'elem__) ->
                perm:((t, perm) Fieldslib.Field.t -> 'elem__) ->
                off:((t, int) Fieldslib.Field.t -> 'elem__) ->
                location:((t, location) Fieldslib.Field.t -> 'elem__) ->
                'elem__ list
              val map_poly :
                ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
                'x0 list
              module Direct :
                sig
                  val iter :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> unit) ->
                    perm:((t, perm) Fieldslib.Field.t -> t -> perm -> unit) ->
                    off:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> unit) ->
                    unit
                  val fold :
                    t ->
                    init:'acc__0 ->
                    name:('acc__0 ->
                          (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> 'acc__1) ->
                    perm:('acc__1 ->
                          (t, perm) Fieldslib.Field.t -> t -> perm -> 'acc__2) ->
                    off:('acc__2 ->
                         (t, int) Fieldslib.Field.t -> t -> int -> 'acc__3) ->
                    location:('acc__3 ->
                              (t, location) Fieldslib.Field.t ->
                              t -> location -> 'acc__4) ->
                    'acc__4
                  val for_all :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> bool) ->
                    perm:((t, perm) Fieldslib.Field.t -> t -> perm -> bool) ->
                    off:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> bool) ->
                    bool
                  val exists :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> bool) ->
                    perm:((t, perm) Fieldslib.Field.t -> t -> perm -> bool) ->
                    off:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> bool) ->
                    bool
                  val to_list :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> 'elem__) ->
                    perm:((t, perm) Fieldslib.Field.t -> t -> perm -> 'elem__) ->
                    off:((t, int) Fieldslib.Field.t -> t -> int -> 'elem__) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> 'elem__) ->
                    'elem__ list
                  val map :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t ->
                          Trie.String.Suffix.key -> Trie.String.Suffix.key) ->
                    perm:((t, perm) Fieldslib.Field.t -> t -> perm -> perm) ->
                    off:((t, int) Fieldslib.Field.t -> t -> int -> int) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> location) ->
                    t
                  val set_all_mutable_fields : t -> unit
                end
            end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
        end
      module Symbol :
        sig
          type t = {
            name : string;
            is_function : bool;
            is_debug : bool;
            locations : Bap.Std.location * Bap.Std.location list;
          }
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val compare : t -> t -> int
          val locations : t -> location * location list
          val is_debug : t -> bool
          val is_function : t -> bool
          val name : t -> Trie.String.Suffix.key
          module Fields :
            sig
              val names : Trie.String.Suffix.key list
              val locations : (t, location * location list) Fieldslib.Field.t
              val is_debug : (t, bool) Fieldslib.Field.t
              val is_function : (t, bool) Fieldslib.Field.t
              val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
              val fold :
                init:'acc__0 ->
                name:('acc__0 ->
                      (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'acc__1) ->
                is_function:('acc__1 ->
                             (t, bool) Fieldslib.Field.t -> 'acc__2) ->
                is_debug:('acc__2 -> (t, bool) Fieldslib.Field.t -> 'acc__3) ->
                locations:('acc__3 ->
                           (t, location * location list) Fieldslib.Field.t ->
                           'acc__4) ->
                'acc__4
              val make_creator :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'acc__0 ->
                      ('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
                is_function:((t, bool) Fieldslib.Field.t ->
                             'acc__1 -> ('input__ -> bool) * 'acc__2) ->
                is_debug:((t, bool) Fieldslib.Field.t ->
                          'acc__2 -> ('input__ -> bool) * 'acc__3) ->
                locations:((t, location * location list) Fieldslib.Field.t ->
                           'acc__3 ->
                           ('input__ -> location * location list) * 'acc__4) ->
                'acc__0 -> ('input__ -> t) * 'acc__4
              val create :
                name:Trie.String.Suffix.key ->
                is_function:bool ->
                is_debug:bool -> locations:location * location list -> t
              val map :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      Trie.String.Suffix.key) ->
                is_function:((t, bool) Fieldslib.Field.t -> bool) ->
                is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
                locations:((t, location * location list) Fieldslib.Field.t ->
                           location * location list) ->
                t
              val iter :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> unit) ->
                is_function:((t, bool) Fieldslib.Field.t -> unit) ->
                is_debug:((t, bool) Fieldslib.Field.t -> unit) ->
                locations:((t, location * location list) Fieldslib.Field.t ->
                           unit) ->
                unit
              val for_all :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> bool) ->
                is_function:((t, bool) Fieldslib.Field.t -> bool) ->
                is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
                locations:((t, location * location list) Fieldslib.Field.t ->
                           bool) ->
                bool
              val exists :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> bool) ->
                is_function:((t, bool) Fieldslib.Field.t -> bool) ->
                is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
                locations:((t, location * location list) Fieldslib.Field.t ->
                           bool) ->
                bool
              val to_list :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'elem__) ->
                is_function:((t, bool) Fieldslib.Field.t -> 'elem__) ->
                is_debug:((t, bool) Fieldslib.Field.t -> 'elem__) ->
                locations:((t, location * location list) Fieldslib.Field.t ->
                           'elem__) ->
                'elem__ list
              val map_poly :
                ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
                'x0 list
              module Direct :
                sig
                  val iter :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> unit) ->
                    is_function:((t, bool) Fieldslib.Field.t ->
                                 t -> bool -> unit) ->
                    is_debug:((t, bool) Fieldslib.Field.t ->
                              t -> bool -> unit) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t ->
                               t -> location * location list -> unit) ->
                    unit
                  val fold :
                    t ->
                    init:'acc__0 ->
                    name:('acc__0 ->
                          (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> 'acc__1) ->
                    is_function:('acc__1 ->
                                 (t, bool) Fieldslib.Field.t ->
                                 t -> bool -> 'acc__2) ->
                    is_debug:('acc__2 ->
                              (t, bool) Fieldslib.Field.t ->
                              t -> bool -> 'acc__3) ->
                    locations:('acc__3 ->
                               (t, location * location list)
                               Fieldslib.Field.t ->
                               t -> location * location list -> 'acc__4) ->
                    'acc__4
                  val for_all :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> bool) ->
                    is_function:((t, bool) Fieldslib.Field.t ->
                                 t -> bool -> bool) ->
                    is_debug:((t, bool) Fieldslib.Field.t ->
                              t -> bool -> bool) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t ->
                               t -> location * location list -> bool) ->
                    bool
                  val exists :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> bool) ->
                    is_function:((t, bool) Fieldslib.Field.t ->
                                 t -> bool -> bool) ->
                    is_debug:((t, bool) Fieldslib.Field.t ->
                              t -> bool -> bool) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t ->
                               t -> location * location list -> bool) ->
                    bool
                  val to_list :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> 'elem__) ->
                    is_function:((t, bool) Fieldslib.Field.t ->
                                 t -> bool -> 'elem__) ->
                    is_debug:((t, bool) Fieldslib.Field.t ->
                              t -> bool -> 'elem__) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t ->
                               t -> location * location list -> 'elem__) ->
                    'elem__ list
                  val map :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t ->
                          Trie.String.Suffix.key -> Trie.String.Suffix.key) ->
                    is_function:((t, bool) Fieldslib.Field.t ->
                                 t -> bool -> bool) ->
                    is_debug:((t, bool) Fieldslib.Field.t ->
                              t -> bool -> bool) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t ->
                               t ->
                               location * location list ->
                               location * location list) ->
                    t
                  val set_all_mutable_fields : t -> unit
                end
            end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
        end
      module Section :
        sig
          type t = { name : string; location : Bap.Std.location; }
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val compare : t -> t -> int
          val location : t -> location
          val name : t -> Trie.String.Suffix.key
          module Fields :
            sig
              val names : Trie.String.Suffix.key list
              val location : (t, location) Fieldslib.Field.t
              val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
              val fold :
                init:'acc__0 ->
                name:('acc__0 ->
                      (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'acc__1) ->
                location:('acc__1 ->
                          (t, location) Fieldslib.Field.t -> 'acc__2) ->
                'acc__2
              val make_creator :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'acc__0 ->
                      ('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
                location:((t, location) Fieldslib.Field.t ->
                          'acc__1 -> ('input__ -> location) * 'acc__2) ->
                'acc__0 -> ('input__ -> t) * 'acc__2
              val create :
                name:Trie.String.Suffix.key -> location:location -> t
              val map :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      Trie.String.Suffix.key) ->
                location:((t, location) Fieldslib.Field.t -> location) -> t
              val iter :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> unit) ->
                location:((t, location) Fieldslib.Field.t -> unit) -> unit
              val for_all :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> bool) ->
                location:((t, location) Fieldslib.Field.t -> bool) -> bool
              val exists :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t -> bool) ->
                location:((t, location) Fieldslib.Field.t -> bool) -> bool
              val to_list :
                name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                      'elem__) ->
                location:((t, location) Fieldslib.Field.t -> 'elem__) ->
                'elem__ list
              val map_poly :
                ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
                'x0 list
              module Direct :
                sig
                  val iter :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> unit) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> unit) ->
                    unit
                  val fold :
                    t ->
                    init:'acc__0 ->
                    name:('acc__0 ->
                          (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> 'acc__1) ->
                    location:('acc__1 ->
                              (t, location) Fieldslib.Field.t ->
                              t -> location -> 'acc__2) ->
                    'acc__2
                  val for_all :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> bool) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> bool) ->
                    bool
                  val exists :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> bool) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> bool) ->
                    bool
                  val to_list :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t -> Trie.String.Suffix.key -> 'elem__) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> 'elem__) ->
                    'elem__ list
                  val map :
                    t ->
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          t ->
                          Trie.String.Suffix.key -> Trie.String.Suffix.key) ->
                    location:((t, location) Fieldslib.Field.t ->
                              t -> location -> location) ->
                    t
                  val set_all_mutable_fields : t -> unit
                end
            end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
        end
      module Img :
        sig
          type t = {
            arch : Bap.Std.arch;
            entry : Bap.Std.addr;
            segments :
              Bap.Std.Backend.Segment.t * Bap.Std.Backend.Segment.t list;
            symbols : Bap.Std.Backend.Symbol.t list;
            sections : Bap.Std.Backend.Section.t list;
          }
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val compare : t -> t -> int
          val sections : t -> Section.t list
          val symbols : t -> Symbol.t list
          val segments : t -> Segment.t * Segment.t list
          val entry : t -> addr
          val arch : t -> arch
          module Fields :
            sig
              val names : Trie.String.Suffix.key list
              val sections : (t, Section.t list) Fieldslib.Field.t
              val symbols : (t, Symbol.t list) Fieldslib.Field.t
              val segments :
                (t, Segment.t * Segment.t list) Fieldslib.Field.t
              val entry : (t, addr) Fieldslib.Field.t
              val arch : (t, arch) Fieldslib.Field.t
              val fold :
                init:'acc__0 ->
                arch:('acc__0 -> (t, arch) Fieldslib.Field.t -> 'acc__1) ->
                entry:('acc__1 -> (t, addr) Fieldslib.Field.t -> 'acc__2) ->
                segments:('acc__2 ->
                          (t, Segment.t * Segment.t list) Fieldslib.Field.t ->
                          'acc__3) ->
                symbols:('acc__3 ->
                         (t, Symbol.t list) Fieldslib.Field.t -> 'acc__4) ->
                sections:('acc__4 ->
                          (t, Section.t list) Fieldslib.Field.t -> 'acc__5) ->
                'acc__5
              val make_creator :
                arch:((t, arch) Fieldslib.Field.t ->
                      'acc__0 -> ('input__ -> arch) * 'acc__1) ->
                entry:((t, addr) Fieldslib.Field.t ->
                       'acc__1 -> ('input__ -> addr) * 'acc__2) ->
                segments:((t, Segment.t * Segment.t list) Fieldslib.Field.t ->
                          'acc__2 ->
                          ('input__ -> Segment.t * Segment.t list) * 'acc__3) ->
                symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                         'acc__3 -> ('input__ -> Symbol.t list) * 'acc__4) ->
                sections:((t, Section.t list) Fieldslib.Field.t ->
                          'acc__4 -> ('input__ -> Section.t list) * 'acc__5) ->
                'acc__0 -> ('input__ -> t) * 'acc__5
              val create :
                arch:arch ->
                entry:addr ->
                segments:Segment.t * Segment.t list ->
                symbols:Symbol.t list -> sections:Section.t list -> t
              val map :
                arch:((t, arch) Fieldslib.Field.t -> arch) ->
                entry:((t, addr) Fieldslib.Field.t -> addr) ->
                segments:((t, Segment.t * Segment.t list) Fieldslib.Field.t ->
                          Segment.t * Segment.t list) ->
                symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                         Symbol.t list) ->
                sections:((t, Section.t list) Fieldslib.Field.t ->
                          Section.t list) ->
                t
              val iter :
                arch:((t, arch) Fieldslib.Field.t -> unit) ->
                entry:((t, addr) Fieldslib.Field.t -> unit) ->
                segments:((t, Segment.t * Segment.t list) Fieldslib.Field.t ->
                          unit) ->
                symbols:((t, Symbol.t list) Fieldslib.Field.t -> unit) ->
                sections:((t, Section.t list) Fieldslib.Field.t -> unit) ->
                unit
              val for_all :
                arch:((t, arch) Fieldslib.Field.t -> bool) ->
                entry:((t, addr) Fieldslib.Field.t -> bool) ->
                segments:((t, Segment.t * Segment.t list) Fieldslib.Field.t ->
                          bool) ->
                symbols:((t, Symbol.t list) Fieldslib.Field.t -> bool) ->
                sections:((t, Section.t list) Fieldslib.Field.t -> bool) ->
                bool
              val exists :
                arch:((t, arch) Fieldslib.Field.t -> bool) ->
                entry:((t, addr) Fieldslib.Field.t -> bool) ->
                segments:((t, Segment.t * Segment.t list) Fieldslib.Field.t ->
                          bool) ->
                symbols:((t, Symbol.t list) Fieldslib.Field.t -> bool) ->
                sections:((t, Section.t list) Fieldslib.Field.t -> bool) ->
                bool
              val to_list :
                arch:((t, arch) Fieldslib.Field.t -> 'elem__) ->
                entry:((t, addr) Fieldslib.Field.t -> 'elem__) ->
                segments:((t, Segment.t * Segment.t list) Fieldslib.Field.t ->
                          'elem__) ->
                symbols:((t, Symbol.t list) Fieldslib.Field.t -> 'elem__) ->
                sections:((t, Section.t list) Fieldslib.Field.t -> 'elem__) ->
                'elem__ list
              val map_poly :
                ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
                'x0 list
              module Direct :
                sig
                  val iter :
                    t ->
                    arch:((t, arch) Fieldslib.Field.t -> t -> arch -> unit) ->
                    entry:((t, addr) Fieldslib.Field.t -> t -> addr -> unit) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t ->
                              t -> Segment.t * Segment.t list -> unit) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                             t -> Symbol.t list -> unit) ->
                    sections:((t, Section.t list) Fieldslib.Field.t ->
                              t -> Section.t list -> unit) ->
                    unit
                  val fold :
                    t ->
                    init:'acc__0 ->
                    arch:('acc__0 ->
                          (t, arch) Fieldslib.Field.t -> t -> arch -> 'acc__1) ->
                    entry:('acc__1 ->
                           (t, addr) Fieldslib.Field.t ->
                           t -> addr -> 'acc__2) ->
                    segments:('acc__2 ->
                              (t, Segment.t * Segment.t list)
                              Fieldslib.Field.t ->
                              t -> Segment.t * Segment.t list -> 'acc__3) ->
                    symbols:('acc__3 ->
                             (t, Symbol.t list) Fieldslib.Field.t ->
                             t -> Symbol.t list -> 'acc__4) ->
                    sections:('acc__4 ->
                              (t, Section.t list) Fieldslib.Field.t ->
                              t -> Section.t list -> 'acc__5) ->
                    'acc__5
                  val for_all :
                    t ->
                    arch:((t, arch) Fieldslib.Field.t -> t -> arch -> bool) ->
                    entry:((t, addr) Fieldslib.Field.t -> t -> addr -> bool) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t ->
                              t -> Segment.t * Segment.t list -> bool) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                             t -> Symbol.t list -> bool) ->
                    sections:((t, Section.t list) Fieldslib.Field.t ->
                              t -> Section.t list -> bool) ->
                    bool
                  val exists :
                    t ->
                    arch:((t, arch) Fieldslib.Field.t -> t -> arch -> bool) ->
                    entry:((t, addr) Fieldslib.Field.t -> t -> addr -> bool) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t ->
                              t -> Segment.t * Segment.t list -> bool) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                             t -> Symbol.t list -> bool) ->
                    sections:((t, Section.t list) Fieldslib.Field.t ->
                              t -> Section.t list -> bool) ->
                    bool
                  val to_list :
                    t ->
                    arch:((t, arch) Fieldslib.Field.t -> t -> arch -> 'elem__) ->
                    entry:((t, addr) Fieldslib.Field.t ->
                           t -> addr -> 'elem__) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t ->
                              t -> Segment.t * Segment.t list -> 'elem__) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                             t -> Symbol.t list -> 'elem__) ->
                    sections:((t, Section.t list) Fieldslib.Field.t ->
                              t -> Section.t list -> 'elem__) ->
                    'elem__ list
                  val map :
                    t ->
                    arch:((t, arch) Fieldslib.Field.t -> t -> arch -> arch) ->
                    entry:((t, addr) Fieldslib.Field.t -> t -> addr -> addr) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t ->
                              t ->
                              Segment.t * Segment.t list ->
                              Segment.t * Segment.t list) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                             t -> Symbol.t list -> Symbol.t list) ->
                    sections:((t, Section.t list) Fieldslib.Field.t ->
                              t -> Section.t list -> Section.t list) ->
                    t
                  val set_all_mutable_fields : t -> unit
                end
            end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
        end
      type t = Core_kernel.Bigstring.t -> Bap.Std.Backend.Img.t option
    end
  module Image :
    sig
      type t = Bap.Std.image
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      type segment
      val bin_segment : segment Core_kernel.Bin_prot.Type_class.t
      val bin_read_segment : segment Core_kernel.Bin_prot.Read.reader
      val __bin_read_segment__ :
        (int -> segment) Core_kernel.Bin_prot.Read.reader
      val bin_reader_segment : segment Core_kernel.Bin_prot.Type_class.reader
      val bin_size_segment : segment Core_kernel.Bin_prot.Size.sizer
      val bin_write_segment : segment Core_kernel.Bin_prot.Write.writer
      val bin_writer_segment : segment Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_segment : Core_kernel.Bin_prot.Shape.t
      val compare_segment : segment -> segment -> int
      val segment_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> segment
      val sexp_of_segment : segment -> Ppx_sexp_conv_lib.Sexp.t
      type symbol
      val bin_symbol : symbol Core_kernel.Bin_prot.Type_class.t
      val bin_read_symbol : symbol Core_kernel.Bin_prot.Read.reader
      val __bin_read_symbol__ :
        (int -> symbol) Core_kernel.Bin_prot.Read.reader
      val bin_reader_symbol : symbol Core_kernel.Bin_prot.Type_class.reader
      val bin_size_symbol : symbol Core_kernel.Bin_prot.Size.sizer
      val bin_write_symbol : symbol Core_kernel.Bin_prot.Write.writer
      val bin_writer_symbol : symbol Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_symbol : Core_kernel.Bin_prot.Shape.t
      val compare_symbol : symbol -> symbol -> int
      val symbol_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> symbol
      val sexp_of_symbol : symbol -> Ppx_sexp_conv_lib.Sexp.t
      type path = string
      type result =
          (Bap.Std.Image.t * Core_kernel.Error.t list) Core_kernel.Or_error.t
      val create :
        ?backend:string -> Bap.Std.Image.path -> Bap.Std.Image.result
      val of_string : ?backend:string -> string -> Bap.Std.Image.result
      val of_bigstring :
        ?backend:string -> Core_kernel.Bigstring.t -> Bap.Std.Image.result
      val entry_point : Bap.Std.Image.t -> Bap.Std.addr
      val filename : Bap.Std.Image.t -> string option
      val arch : Bap.Std.Image.t -> Bap.Std.arch
      val addr_size : Bap.Std.Image.t -> Bap.Std.addr_size
      val endian : Bap.Std.Image.t -> Bap.Std.endian
      val words :
        Bap.Std.Image.t -> Bap.Std.size -> Bap.Std.word Bap.Std.table
      val segments : Bap.Std.Image.t -> Bap.Std.Image.segment Bap.Std.table
      val symbols : Bap.Std.Image.t -> Bap.Std.Image.symbol Bap.Std.table
      val segment : Bap.Std.Image.segment Bap.Std.tag
      val symbol : string Bap.Std.tag
      val section : string Bap.Std.tag
      val specification : Ogre.doc Bap.Std.tag
      val memory : Bap.Std.Image.t -> Bap.Std.value Bap.Std.memmap
      val memory_of_segment :
        Bap.Std.Image.t -> Bap.Std.Image.segment -> Bap.Std.mem
      val memory_of_symbol :
        Bap.Std.Image.t ->
        Bap.Std.Image.symbol -> Bap.Std.mem * Bap.Std.mem Bap.Std.seq
      val symbols_of_segment :
        Bap.Std.Image.t ->
        Bap.Std.Image.segment -> Bap.Std.Image.symbol Bap.Std.seq
      val segment_of_symbol :
        Bap.Std.Image.t -> Bap.Std.Image.symbol -> Bap.Std.Image.segment
      module Segment :
        sig
          type t = Bap.Std.Image.segment
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.Image.segment
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_increasing_sequence :
                    (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Value.Table.hashtbl -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:Key.t ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
                  val set : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val find_multi : 'a list t -> Key.t -> 'a list
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Key.t
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Value.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (Elt.t, 'a) Value.Table.hashtbl -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Value.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Value.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val name : Bap.Std.Image.Segment.t -> string
          val is_writable : Bap.Std.Image.Segment.t -> bool
          val is_readable : Bap.Std.Image.Segment.t -> bool
          val is_executable : Bap.Std.Image.Segment.t -> bool
        end
      module Symbol :
        sig
          type t = Bap.Std.Image.symbol
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.Image.symbol
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_increasing_sequence :
                    (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Segment.Table.hashtbl -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:Key.t ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
                  val set : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val find_multi : 'a list t -> Key.t -> 'a list
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Key.t
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Segment.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Segment.Table.hashtbl -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Segment.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Segment.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val name : Bap.Std.Image.Symbol.t -> string
          val is_function : Bap.Std.Image.Symbol.t -> bool
          val is_debug : Bap.Std.Image.Symbol.t -> bool
        end
      module type Loader =
        sig
          val from_file : string -> Ogre.doc option Core_kernel.Or_error.t
          val from_data :
            Core_kernel.Bigstring.t -> Ogre.doc option Core_kernel.Or_error.t
        end
      val register_loader :
        name:string -> (module Bap.Std.Image.Loader-> unit
      val available_backends : unit -> string list
      val register_backend :
        name:string -> Bap.Std.Backend.t -> [ `Duplicate | `Ok ]
      val data : Bap.Std.Image.t -> Core_kernel.Bigstring.t
      val spec : Bap.Std.Image.t -> Ogre.doc
      module Scheme :
        sig
          type addr = int64
          type size = int64
          type off = int64
          type 'a region = {
            addr : Bap.Std.Image.Scheme.addr;
            size : Bap.Std.Image.Scheme.size;
            info : 'a;
          }
          val off : Bap.Std.Image.Scheme.off Ogre.field
          val size : Bap.Std.Image.Scheme.size Ogre.field
          val addr : Bap.Std.Image.Scheme.addr Ogre.field
          val name : string Ogre.field
          val root : Bap.Std.Image.Scheme.addr Ogre.field
          val readable : bool Ogre.field
          val writable : bool Ogre.field
          val executable : bool Ogre.field
          val fixup : Bap.Std.Image.Scheme.addr Ogre.field
          val arch : (string, (string -> 'a) -> 'a) Ogre.attribute
          val segment :
            ((bool * bool * bool) Bap.Std.Image.Scheme.region,
             (Bap.Std.Image.Scheme.addr ->
              Bap.Std.Image.Scheme.size -> bool -> bool -> bool -> 'a) ->
             'a)
            Ogre.attribute
          val section :
            (unit Bap.Std.Image.Scheme.region,
             (Bap.Std.Image.Scheme.addr -> Bap.Std.Image.Scheme.size -> 'a) ->
             'a)
            Ogre.attribute
          val code_start :
            (Bap.Std.Image.Scheme.addr,
             (Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
            Ogre.attribute
          val entry_point :
            (Bap.Std.Image.Scheme.addr,
             (Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
            Ogre.attribute
          val symbol_chunk :
            (Bap.Std.Image.Scheme.addr Bap.Std.Image.Scheme.region,
             (Bap.Std.Image.Scheme.addr ->
              Bap.Std.Image.Scheme.size -> Bap.Std.Image.Scheme.addr -> 'a) ->
             'a)
            Ogre.attribute
          val named_region :
            (string Bap.Std.Image.Scheme.region,
             (Bap.Std.Image.Scheme.addr ->
              Bap.Std.Image.Scheme.size -> string -> 'a) ->
             'a)
            Ogre.attribute
          val named_symbol :
            (Bap.Std.Image.Scheme.addr * string,
             (Bap.Std.Image.Scheme.addr -> string -> 'a) -> 'a)
            Ogre.attribute
          val mapped :
            (Bap.Std.Image.Scheme.off Bap.Std.Image.Scheme.region,
             (Bap.Std.Image.Scheme.addr ->
              Bap.Std.Image.Scheme.size -> Bap.Std.Image.Scheme.off -> 'a) ->
             'a)
            Ogre.attribute
          val relocation :
            (int64 * Bap.Std.Image.Scheme.addr,
             (Bap.Std.Image.Scheme.addr -> Bap.Std.Image.Scheme.addr -> 'a) ->
             'a)
            Ogre.attribute
          val external_reference :
            (Bap.Std.Image.Scheme.addr * string,
             (Bap.Std.Image.Scheme.addr -> string -> 'a) -> 'a)
            Ogre.attribute
          val base_address :
            (Bap.Std.Image.Scheme.addr,
             (Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
            Ogre.attribute
        end
    end
  module Memmap :
    sig
      type 'a t = 'Bap.Std.memmap
      val sexp_of_t :
        ('-> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t
      val empty : 'Bap.Std.Memmap.t
      val singleton : Bap.Std.mem -> '-> 'Bap.Std.Memmap.t
      val min_addr : 'Bap.Std.Memmap.t -> Bap.Std.addr option
      val max_addr : 'Bap.Std.Memmap.t -> Bap.Std.addr option
      val min_binding : 'Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) option
      val max_binding : 'Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) option
      val add :
        'Bap.Std.Memmap.t -> Bap.Std.mem -> '-> 'Bap.Std.Memmap.t
      val dominators :
        'Bap.Std.Memmap.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
      val intersections :
        'Bap.Std.Memmap.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
      val intersects : 'Bap.Std.Memmap.t -> Bap.Std.mem -> bool
      val dominates : 'Bap.Std.Memmap.t -> Bap.Std.mem -> bool
      val contains : 'Bap.Std.Memmap.t -> Bap.Std.addr -> bool
      val lookup :
        'Bap.Std.Memmap.t -> Bap.Std.addr -> (Bap.Std.mem * 'a) Bap.Std.seq
      val map : 'Bap.Std.Memmap.t -> f:('-> 'b) -> 'Bap.Std.Memmap.t
      val mapi :
        'Bap.Std.Memmap.t ->
        f:(Bap.Std.mem -> '-> 'b) -> 'Bap.Std.Memmap.t
      val filter :
        'Bap.Std.Memmap.t -> f:('-> bool) -> 'Bap.Std.Memmap.t
      val filter_map :
        'Bap.Std.Memmap.t -> f:('-> 'b option) -> 'Bap.Std.Memmap.t
      val filter_mapi :
        'Bap.Std.Memmap.t ->
        f:(Bap.Std.mem -> '-> 'b option) -> 'Bap.Std.Memmap.t
      val remove : 'Bap.Std.Memmap.t -> Bap.Std.mem -> 'Bap.Std.Memmap.t
      val remove_intersections :
        'Bap.Std.Memmap.t -> Bap.Std.mem -> 'Bap.Std.Memmap.t
      val remove_dominators :
        'Bap.Std.Memmap.t -> Bap.Std.mem -> 'Bap.Std.Memmap.t
      val to_sequence : 'Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) Bap.Std.seq
      val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('-> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
      val fold_result :
        'a t ->
        init:'accum ->
        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
        ('accum, 'e) Base__.Result.t
      val fold_until :
        'a t ->
        init:'accum ->
        f:('accum ->
           '-> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
        finish:('accum -> 'final) -> 'final
      val exists : 'a t -> f:('-> bool) -> bool
      val for_all : 'a t -> f:('-> bool) -> bool
      val count : 'a t -> f:('-> bool) -> int
      val sum :
        (module Base__.Commutative_group.S with type t = 'sum) ->
        'a t -> f:('-> 'sum) -> 'sum
      val find : 'a t -> f:('-> bool) -> 'a option
      val find_map : 'a t -> f:('-> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
      val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
      val pp :
        'Regular.Std.printer -> 'Bap.Std.Memmap.t Regular.Std.printer
    end
  type symbolizer
  type rooter
  type brancher
  type reconstructor
  type disasm
  type insn
  val bin_insn : insn Core_kernel.Bin_prot.Type_class.t
  val bin_read_insn : insn Core_kernel.Bin_prot.Read.reader
  val __bin_read_insn__ : (int -> insn) Core_kernel.Bin_prot.Read.reader
  val bin_reader_insn : insn Core_kernel.Bin_prot.Type_class.reader
  val bin_size_insn : insn Core_kernel.Bin_prot.Size.sizer
  val bin_write_insn : insn Core_kernel.Bin_prot.Write.writer
  val bin_writer_insn : insn Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_insn : Core_kernel.Bin_prot.Shape.t
  val compare_insn : insn -> insn -> int
  val sexp_of_insn : insn -> Ppx_sexp_conv_lib.Sexp.t
  type block
  val compare_block : block -> block -> int
  val sexp_of_block : block -> Ppx_sexp_conv_lib.Sexp.t
  type cfg
  val compare_cfg : cfg -> cfg -> int
  type jump = [ `Cond | `Jump ]
  val compare_jump : jump -> jump -> int
  val jump_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> jump
  val __jump_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> jump
  val sexp_of_jump : jump -> Ppx_sexp_conv_lib.Sexp.t
  type edge = [ `Cond | `Fall | `Jump ]
  val compare_edge : edge -> edge -> int
  val edge_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
  val __edge_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> edge
  val sexp_of_edge : edge -> Ppx_sexp_conv_lib.Sexp.t
  module Kind :
    sig
      type branch =
          [ `Conditional_branch | `Indirect_branch | `Unconditional_branch ]
      val bin_branch : branch Core_kernel.Bin_prot.Type_class.t
      val bin_read_branch : branch Core_kernel.Bin_prot.Read.reader
      val __bin_read_branch__ :
        (int -> branch) Core_kernel.Bin_prot.Read.reader
      val bin_reader_branch : branch Core_kernel.Bin_prot.Type_class.reader
      val bin_size_branch : branch Core_kernel.Bin_prot.Size.sizer
      val bin_write_branch : branch Core_kernel.Bin_prot.Write.writer
      val bin_writer_branch : branch Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_branch : Core_kernel.Bin_prot.Shape.t
      val compare_branch : branch -> branch -> int
      val all_of_branch : branch list
      val branch_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> branch
      val __branch_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> branch
      val sexp_of_branch : branch -> Ppx_sexp_conv_lib.Sexp.t
      type affecting_control =
          [ `Barrier
          | `Call
          | `Conditional_branch
          | `Indirect_branch
          | `May_affect_control_flow
          | `Return
          | `Terminator
          | `Unconditional_branch ]
      val bin_affecting_control :
        affecting_control Core_kernel.Bin_prot.Type_class.t
      val bin_read_affecting_control :
        affecting_control Core_kernel.Bin_prot.Read.reader
      val __bin_read_affecting_control__ :
        (int -> affecting_control) Core_kernel.Bin_prot.Read.reader
      val bin_reader_affecting_control :
        affecting_control Core_kernel.Bin_prot.Type_class.reader
      val bin_size_affecting_control :
        affecting_control Core_kernel.Bin_prot.Size.sizer
      val bin_write_affecting_control :
        affecting_control Core_kernel.Bin_prot.Write.writer
      val bin_writer_affecting_control :
        affecting_control Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_affecting_control : Core_kernel.Bin_prot.Shape.t
      val compare_affecting_control :
        affecting_control -> affecting_control -> int
      val all_of_affecting_control : affecting_control list
      val affecting_control_of_sexp :
        Ppx_sexp_conv_lib.Sexp.t -> affecting_control
      val __affecting_control_of_sexp__ :
        Ppx_sexp_conv_lib.Sexp.t -> affecting_control
      val sexp_of_affecting_control :
        affecting_control -> Ppx_sexp_conv_lib.Sexp.t
      type having_side_effect = [ `May_load | `May_store ]
      val bin_having_side_effect :
        having_side_effect Core_kernel.Bin_prot.Type_class.t
      val bin_read_having_side_effect :
        having_side_effect Core_kernel.Bin_prot.Read.reader
      val __bin_read_having_side_effect__ :
        (int -> having_side_effect) Core_kernel.Bin_prot.Read.reader
      val bin_reader_having_side_effect :
        having_side_effect Core_kernel.Bin_prot.Type_class.reader
      val bin_size_having_side_effect :
        having_side_effect Core_kernel.Bin_prot.Size.sizer
      val bin_write_having_side_effect :
        having_side_effect Core_kernel.Bin_prot.Write.writer
      val bin_writer_having_side_effect :
        having_side_effect Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_having_side_effect : Core_kernel.Bin_prot.Shape.t
      val compare_having_side_effect :
        having_side_effect -> having_side_effect -> int
      val all_of_having_side_effect : having_side_effect list
      val having_side_effect_of_sexp :
        Ppx_sexp_conv_lib.Sexp.t -> having_side_effect
      val __having_side_effect_of_sexp__ :
        Ppx_sexp_conv_lib.Sexp.t -> having_side_effect
      val sexp_of_having_side_effect :
        having_side_effect -> Ppx_sexp_conv_lib.Sexp.t
      type t =
          [ `Barrier
          | `Call
          | `Conditional_branch
          | `Indirect_branch
          | `May_affect_control_flow
          | `May_load
          | `May_store
          | `Return
          | `Terminator
          | `Unconditional_branch ]
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val compare : t -> t -> int
      val all : t list
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val __t_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
    end
  type reg
  val bin_reg : reg Core_kernel.Bin_prot.Type_class.t
  val bin_read_reg : reg Core_kernel.Bin_prot.Read.reader
  val __bin_read_reg__ : (int -> reg) Core_kernel.Bin_prot.Read.reader
  val bin_reader_reg : reg Core_kernel.Bin_prot.Type_class.reader
  val bin_size_reg : reg Core_kernel.Bin_prot.Size.sizer
  val bin_write_reg : reg Core_kernel.Bin_prot.Write.writer
  val bin_writer_reg : reg Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_reg : Core_kernel.Bin_prot.Shape.t
  val compare_reg : reg -> reg -> int
  val reg_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> reg
  val sexp_of_reg : reg -> Ppx_sexp_conv_lib.Sexp.t
  type imm
  val bin_imm : imm Core_kernel.Bin_prot.Type_class.t
  val bin_read_imm : imm Core_kernel.Bin_prot.Read.reader
  val __bin_read_imm__ : (int -> imm) Core_kernel.Bin_prot.Read.reader
  val bin_reader_imm : imm Core_kernel.Bin_prot.Type_class.reader
  val bin_size_imm : imm Core_kernel.Bin_prot.Size.sizer
  val bin_write_imm : imm Core_kernel.Bin_prot.Write.writer
  val bin_writer_imm : imm Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_imm : Core_kernel.Bin_prot.Shape.t
  val compare_imm : imm -> imm -> int
  val imm_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> imm
  val sexp_of_imm : imm -> Ppx_sexp_conv_lib.Sexp.t
  type fmm
  val bin_fmm : fmm Core_kernel.Bin_prot.Type_class.t
  val bin_read_fmm : fmm Core_kernel.Bin_prot.Read.reader
  val __bin_read_fmm__ : (int -> fmm) Core_kernel.Bin_prot.Read.reader
  val bin_reader_fmm : fmm Core_kernel.Bin_prot.Type_class.reader
  val bin_size_fmm : fmm Core_kernel.Bin_prot.Size.sizer
  val bin_write_fmm : fmm Core_kernel.Bin_prot.Write.writer
  val bin_writer_fmm : fmm Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_fmm : Core_kernel.Bin_prot.Shape.t
  val compare_fmm : fmm -> fmm -> int
  val fmm_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> fmm
  val sexp_of_fmm : fmm -> Ppx_sexp_conv_lib.Sexp.t
  type kind = Bap.Std.Kind.t
  val bin_kind : kind Core_kernel.Bin_prot.Type_class.t
  val bin_read_kind : kind Core_kernel.Bin_prot.Read.reader
  val __bin_read_kind__ : (int -> kind) Core_kernel.Bin_prot.Read.reader
  val bin_reader_kind : kind Core_kernel.Bin_prot.Type_class.reader
  val bin_size_kind : kind Core_kernel.Bin_prot.Size.sizer
  val bin_write_kind : kind Core_kernel.Bin_prot.Write.writer
  val bin_writer_kind : kind Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_kind : Core_kernel.Bin_prot.Shape.t
  val compare_kind : kind -> kind -> int
  val kind_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> kind
  val sexp_of_kind : kind -> Ppx_sexp_conv_lib.Sexp.t
  module Reg :
    sig
      type t = Bap.Std.reg
      val code : Bap.Std.Reg.t -> int
      val name : Bap.Std.Reg.t -> string
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.reg
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Value.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Value.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Value.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Value.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Value.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Imm :
    sig
      type t = Bap.Std.imm
      val to_word : Bap.Std.Imm.t -> width:int -> Bap.Std.word option
      val to_int64 : Bap.Std.Imm.t -> int64
      val to_int : Bap.Std.Imm.t -> int option
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.imm
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Reg.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Reg.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Reg.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Reg.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Reg.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Fmm :
    sig
      type t = Bap.Std.fmm
      val to_float : Bap.Std.Fmm.t -> float
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.fmm
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Imm.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Imm.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Imm.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Imm.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Imm.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Op :
    sig
      type t = Reg of Bap.Std.reg | Imm of Bap.Std.imm | Fmm of Bap.Std.fmm
      module Normalized :
        sig
          val compare : Bap.Std.Op.t -> Bap.Std.Op.t -> int
          val hash : Bap.Std.Op.t -> int
          val compare_ops : Bap.Std.Op.t array -> Bap.Std.Op.t array -> int
        end
      val pp_adt : Format.formatter -> Bap.Std.Op.t -> unit
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Fmm.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Fmm.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Fmm.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Fmm.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Fmm.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  type op = Bap.Std.Op.t
  val bin_op : op Core_kernel.Bin_prot.Type_class.t
  val bin_read_op : op Core_kernel.Bin_prot.Read.reader
  val __bin_read_op__ : (int -> op) Core_kernel.Bin_prot.Read.reader
  val bin_reader_op : op Core_kernel.Bin_prot.Type_class.reader
  val bin_size_op : op Core_kernel.Bin_prot.Size.sizer
  val bin_write_op : op Core_kernel.Bin_prot.Write.writer
  val bin_writer_op : op Core_kernel.Bin_prot.Type_class.writer
  val bin_shape_op : Core_kernel.Bin_prot.Shape.t
  val compare_op : op -> op -> int
  val sexp_of_op : op -> Ppx_sexp_conv_lib.Sexp.t
  module Disasm_expert :
    sig
      module Basic :
        sig
          type pred =
              [ `Barrier
              | `Call
              | `Conditional_branch
              | `Indirect_branch
              | `May_affect_control_flow
              | `May_load
              | `May_store
              | `Return
              | `Terminator
              | `Unconditional_branch
              | `Valid ]
          val pred_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> pred
          val __pred_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> pred
          val sexp_of_pred : pred -> Ppx_sexp_conv_lib.Sexp.t
          type (+'a, +'k) insn
          type ('a, 'k) insns =
              (Bap.Std.mem * ('a, 'k) Bap.Std.Disasm_expert.Basic.insn option)
              list
          type empty
          type asm
          type kinds
          type full_insn =
              (Bap.Std.Disasm_expert.Basic.asm,
               Bap.Std.Disasm_expert.Basic.kinds)
              Bap.Std.Disasm_expert.Basic.insn
          val compare_full_insn : full_insn -> full_insn -> int
          val sexp_of_full_insn : full_insn -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'k) t
          type (+'a, +'k, 's, 'r) state
          val with_disasm :
            ?debug_level:int ->
            ?cpu:string ->
            backend:string ->
            string ->
            f:((Bap.Std.Disasm_expert.Basic.empty,
                Bap.Std.Disasm_expert.Basic.empty)
               Bap.Std.Disasm_expert.Basic.t -> 'Core_kernel.Or_error.t) ->
            'Core_kernel.Or_error.t
          val create :
            ?debug_level:int ->
            ?cpu:string ->
            backend:string ->
            string ->
            (Bap.Std.Disasm_expert.Basic.empty,
             Bap.Std.Disasm_expert.Basic.empty)
            Bap.Std.Disasm_expert.Basic.t Core_kernel.Or_error.t
          val close : ('a, 'b) Bap.Std.Disasm_expert.Basic.t -> unit
          val store_asm :
            ('a, 'k) Bap.Std.Disasm_expert.Basic.t ->
            (Bap.Std.Disasm_expert.Basic.asm, 'k)
            Bap.Std.Disasm_expert.Basic.t
          val store_kinds :
            ('a, 'b) Bap.Std.Disasm_expert.Basic.t ->
            ('a, Bap.Std.Disasm_expert.Basic.kinds)
            Bap.Std.Disasm_expert.Basic.t
          val run :
            ?backlog:int ->
            ?stop_on:Bap.Std.Disasm_expert.Basic.pred list ->
            ?invalid:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                      Bap.Std.mem -> '-> 'r) ->
            ?stopped:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                      '-> 'r) ->
            ?hit:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                  Bap.Std.mem ->
                  (Bap.Std.Disasm_expert.Basic.asm,
                   Bap.Std.Disasm_expert.Basic.kinds)
                  Bap.Std.Disasm_expert.Basic.insn -> '-> 'r) ->
            ('a, 'k) Bap.Std.Disasm_expert.Basic.t ->
            return:('-> 'r) -> init:'-> Bap.Std.mem -> 'r
          val insn_of_mem :
            ('a, 'b) Bap.Std.Disasm_expert.Basic.t ->
            Bap.Std.mem ->
            (Bap.Std.mem *
             (Bap.Std.Disasm_expert.Basic.asm,
              Bap.Std.Disasm_expert.Basic.kinds)
             Bap.Std.Disasm_expert.Basic.insn option *
             [ `finished | `left of Bap.Std.mem ])
            Core_kernel.Or_error.t
          val addr :
            ('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
            Bap.Std.addr
          val preds :
            ('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
            Bap.Std.Disasm_expert.Basic.pred list
          val with_preds :
            ('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
            Bap.Std.Disasm_expert.Basic.pred list ->
            ('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state
          val insns :
            ('a, 'k, 'b, 'c) Bap.Std.Disasm_expert.Basic.state ->
            ('a, 'k) Bap.Std.Disasm_expert.Basic.insns
          val last :
            ('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
            int -> ('a, 'k) Bap.Std.Disasm_expert.Basic.insns
          val memory :
            ('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state -> Bap.Std.mem
          val stop :
            ('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state -> '-> 'r
          val step :
            ('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state -> '-> 'r
          val jump :
            ('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
            Bap.Std.mem -> '-> 'r
          val back :
            ('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state -> '-> 'r
          module Insn :
            sig
              type ('a, 'k) t = ('a, 'k) Bap.Std.Disasm_expert.Basic.insn
              val sexp_of_t :
                ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
                Core_kernel.Sexp.t
              val compare :
                ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
                ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> int
              val code : ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> int
              val name :
                ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> string
              val kinds :
                ('a, Bap.Std.Disasm_expert.Basic.kinds)
                Bap.Std.Disasm_expert.Basic.Insn.t -> Bap.Std.Kind.t list
              val is :
                ('a, Bap.Std.Disasm_expert.Basic.kinds)
                Bap.Std.Disasm_expert.Basic.Insn.t -> Bap.Std.Kind.t -> bool
              val asm :
                (Bap.Std.Disasm_expert.Basic.asm, 'k)
                Bap.Std.Disasm_expert.Basic.Insn.t -> string
              val ops :
                ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
                Bap.Std.op array
            end
          module Trie :
            sig
              type key
              val key_of_first_insns :
                ('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
                len:int -> Bap.Std.Disasm_expert.Basic.Trie.key option
              module Normalized :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Bin_prot.Read.reader ->
                    'a t Core_kernel.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Bin_prot.Write.writer ->
                    'a t Core_kernel.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Bin_prot.Shape.t ->
                    Core_kernel.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  type key = key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          val available_backends : unit -> string list
        end
      module Linear :
        sig
          type t = (Bap.Std.mem * Bap.Std.insn option) list
          val sweep :
            ?backend:string ->
            Bap.Std.arch ->
            Bap.Std.mem ->
            Bap.Std.Disasm_expert.Linear.t Core_kernel.Or_error.t
          module With_exn :
            sig
              val sweep :
                ?backend:string ->
                Bap.Std.arch -> Bap.Std.mem -> Bap.Std.Disasm_expert.Linear.t
            end
        end
      module Recursive :
        sig
          type t
          type error =
              [ `Failed_to_disasm of Bap.Std.mem
              | `Failed_to_lift of
                  Bap.Std.mem * Bap.Std.Disasm_expert.Basic.full_insn *
                  Core_kernel.Error.t ]
          val sexp_of_error : error -> Ppx_sexp_conv_lib.Sexp.t
          val run :
            ?backend:string ->
            ?brancher:Bap.Std.brancher ->
            ?rooter:Bap.Std.rooter ->
            Bap.Std.arch ->
            Bap.Std.mem ->
            Bap.Std.Disasm_expert.Recursive.t Core_kernel.Or_error.t
          val cfg : Bap.Std.Disasm_expert.Recursive.t -> Bap.Std.cfg
          val errors :
            Bap.Std.Disasm_expert.Recursive.t ->
            Bap.Std.Disasm_expert.Recursive.error list
        end
    end
  module Insn :
    sig
      type t = Bap.Std.insn
      val of_basic :
        ?bil:Bap.Std.bil ->
        Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Insn.t
      val name : Bap.Std.Insn.t -> string
      val asm : Bap.Std.Insn.t -> string
      val bil : Bap.Std.Insn.t -> Bap.Std.bil
      val ops : Bap.Std.Insn.t -> Bap.Std.op array
      type must = Must
      type may = May
      type 'a property
      val new_property : '-> string -> 'Bap.Std.Insn.property
      val jump : Bap.Std.Insn.must Bap.Std.Insn.property
      val conditional : Bap.Std.Insn.must Bap.Std.Insn.property
      val indirect : Bap.Std.Insn.must Bap.Std.Insn.property
      val call : Bap.Std.Insn.must Bap.Std.Insn.property
      val return : Bap.Std.Insn.must Bap.Std.Insn.property
      val affect_control_flow : Bap.Std.Insn.may Bap.Std.Insn.property
      val load : Bap.Std.Insn.may Bap.Std.Insn.property
      val store : Bap.Std.Insn.may Bap.Std.Insn.property
      val is :
        Bap.Std.Insn.must Bap.Std.Insn.property -> Bap.Std.Insn.t -> bool
      val may :
        Bap.Std.Insn.may Bap.Std.Insn.property -> Bap.Std.Insn.t -> bool
      val must :
        Bap.Std.Insn.must Bap.Std.Insn.property ->
        Bap.Std.Insn.t -> Bap.Std.Insn.t
      val mustn't :
        Bap.Std.Insn.must Bap.Std.Insn.property ->
        Bap.Std.Insn.t -> Bap.Std.Insn.t
      val should :
        Bap.Std.Insn.may Bap.Std.Insn.property ->
        Bap.Std.Insn.t -> Bap.Std.Insn.t
      val shouldn't :
        Bap.Std.Insn.may Bap.Std.Insn.property ->
        Bap.Std.Insn.t -> Bap.Std.Insn.t
      val pp_adt : Bap.Std.Insn.t Regular.Std.printer
      module Trie :
        sig
          type key
          val key_of_insns : Bap.Std.Insn.t list -> Bap.Std.Insn.Trie.key
          module Normalized :
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Bin_prot.Type_class.t ->
                'a t Core_kernel.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Bin_prot.Read.reader ->
                'a t Core_kernel.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Bin_prot.Size.sizer ->
                'a t Core_kernel.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Bin_prot.Write.writer ->
                'a t Core_kernel.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              type key = key
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          type 'a t
          val bin_t :
            'Core_kernel.Bin_prot.Type_class.t ->
            'a t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t :
            'Core_kernel.Bin_prot.Read.reader ->
            'a t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ :
            'Core_kernel.Bin_prot.Read.reader ->
            (int -> 'a t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t :
            'Core_kernel.Bin_prot.Type_class.reader ->
            'a t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t :
            'Core_kernel.Bin_prot.Size.sizer ->
            'a t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t :
            'Core_kernel.Bin_prot.Write.writer ->
            'a t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t :
            'Core_kernel.Bin_prot.Type_class.writer ->
            'a t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t :
            Core_kernel.Bin_prot.Shape.t -> Core_kernel.Bin_prot.Shape.t
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val create : unit -> 'a t
          val add : 'a t -> key:key -> data:'-> unit
          val change : 'a t -> key -> ('a option -> 'a option) -> unit
          val find : 'a t -> key -> 'a option
          val walk :
            'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
          val remove : 'a t -> key -> unit
          val longest_match : 'a t -> key -> (int * 'a) option
          val length : 'a t -> int
          val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
        end
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> string
      val str : unit -> t -> string
      val pps : unit -> t -> string
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.insn
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Op.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Op.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> string) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Op.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Op.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Op.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> string) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info = string * [ `Ver of string ] * string option
      val version : string
      val size_in_bytes : ?ver:string -> ?fmt:string -> t -> int
      val of_bytes : ?ver:string -> ?fmt:string -> Regular.Std.bytes -> t
      val to_bytes : ?ver:string -> ?fmt:string -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:string -> ?fmt:string -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:string -> ?fmt:string -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:string -> ?fmt:string -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:string ->
        ?fmt:string -> Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read : ?ver:string -> ?fmt:string -> string -> t
          val load :
            ?ver:string -> ?fmt:string -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:string ->
            ?fmt:string -> ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:string ->
            ?fmt:string -> Core_kernel.In_channel.t -> unit -> t option
          val write : ?ver:string -> ?fmt:string -> string -> t -> unit
          val save :
            ?ver:string ->
            ?fmt:string -> Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:string ->
            ?fmt:string -> Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:string ->
            ?fmt:string ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show : ?ver:string -> ?fmt:string -> t -> unit
          val print :
            ?ver:string -> ?fmt:string -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:string -> ver:string -> string -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:string -> ver:string -> string -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader : ?ver:string -> string -> unit
      val with_reader : ?ver:string -> string -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer : ?ver:string -> string -> unit
      val with_writer : ?ver:string -> string -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer : ?ver:string -> string -> unit
      val with_printer : ?ver:string -> string -> (unit -> 'a) -> 'a
      val find_reader : ?ver:string -> string -> t Regular.Std.reader option
      val find_writer : ?ver:string -> string -> t Regular.Std.writer option
    end
  module Block :
    sig
      type t = Bap.Std.block
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val create :
        Bap.Std.mem -> (Bap.Std.mem * Bap.Std.insn) list -> Bap.Std.Block.t
      val addr : Bap.Std.Block.t -> Bap.Std.addr
      val memory : Bap.Std.Block.t -> Bap.Std.mem
      val leader : Bap.Std.Block.t -> Bap.Std.insn
      val terminator : Bap.Std.Block.t -> Bap.Std.insn
      val insns : Bap.Std.Block.t -> (Bap.Std.mem * Bap.Std.insn) list
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val comparator : (t, comparator_witness) Base__.Comparator.comparator
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.block
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Insn.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Insn.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Insn.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Insn.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
        end
      val compare : t -> t -> Core_kernel__.Import.int
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Insn.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
    end
  module Graphs :
    sig
      module Cfg :
        sig
          type t = cfg
          type node = block
          type edge
          module Node :
            sig
              type t = node
              type graph = cfg
              type label
              type edge = edge
              val create : label -> t
              val label : t -> label
              val mem : t -> graph -> bool
              val succs : t -> graph -> t Regular.Std.seq
              val preds : t -> graph -> t Regular.Std.seq
              val inputs : t -> graph -> edge Regular.Std.seq
              val outputs : t -> graph -> edge Regular.Std.seq
              val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
              val insert : t -> graph -> graph
              val update : t -> label -> graph -> graph
              val remove : t -> graph -> graph
              val has_edge : t -> t -> graph -> bool
              val edge : t -> t -> graph -> edge option
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = node
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (node, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : node -> '-> 'a t
                      val of_alist :
                        (node * 'a) list ->
                        [ `Duplicate_key of node | `Ok of 'a t ]
                      val of_alist_or_error :
                        (node * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (node * 'a) list -> 'a t
                      val of_alist_multi : (node * 'a) list -> 'a list t
                      val of_alist_fold :
                        (node * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (node * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (node * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node * 'a) -> 'a t
                      val of_increasing_sequence :
                        (node * 'a) Base__.Sequence.t ->
                        'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of node | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (node, 'a) Block.Table.hashtbl -> 'a t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:node ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:node -> data:'-> 'a t
                      val set : 'a t -> key:node -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:node -> data:'-> 'a list t
                      val remove_multi : 'a list t -> node -> 'a list t
                      val find_multi : 'a list t -> node -> 'a list
                      val change :
                        'a t -> node -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> node -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> node -> 'a option
                      val find_exn : 'a t -> node -> 'a
                      val remove : 'a t -> node -> 'a t
                      val mem : 'a t -> node -> bool
                      val iter_keys : 'a t -> f:(node -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:node -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:node -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:node -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:node -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> node list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (node * 'a) list
                      val validate :
                        name:(node -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (node * 'a) option
                      val min_elt_exn : 'a t -> node * 'a
                      val max_elt : 'a t -> (node * 'a) option
                      val max_elt_exn : 'a t -> node * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:node -> data:'-> bool) -> int
                      val split :
                        'a t -> node -> 'a t * (node * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:node Base__.Maybe_bound.t ->
                        upper_bound:node Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:node ->
                        max:node ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:node -> max:node -> (node * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> node -> (node * 'a) option
                      val nth : 'a t -> int -> (node * 'a) option
                      val nth_exn : 'a t -> int -> node * 'a
                      val rank : 'a t -> node -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:node ->
                        ?keys_less_or_equal_to:node ->
                        'a t -> (node * 'a) Base__.Sequence.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> node
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (node, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : node -> '-> 'a t
                  val of_alist :
                    (node * 'a) list ->
                    [ `Duplicate_key of node | `Ok of 'a t ]
                  val of_alist_or_error :
                    (node * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (node * 'a) list -> 'a t
                  val of_alist_multi : (node * 'a) list -> 'a list t
                  val of_alist_fold :
                    (node * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (node * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> node * 'a) -> 'a t
                  val of_increasing_sequence :
                    (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of node | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn : (node, 'a) Block.Table.hashtbl -> 'a t
                  val gen :
                    node Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:node ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:node -> data:'-> 'a t
                  val set : 'a t -> key:node -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:node -> data:'-> 'a list t
                  val remove_multi : 'a list t -> node -> 'a list t
                  val find_multi : 'a list t -> node -> 'a list
                  val change :
                    'a t -> node -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> node -> 'a option
                  val find_exn : 'a t -> node -> 'a
                  val remove : 'a t -> node -> 'a t
                  val mem : 'a t -> node -> bool
                  val iter_keys : 'a t -> f:(node -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:node -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:node ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:node ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:node -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:node -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:node -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> node list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (node * 'a) list
                  val validate :
                    name:(node -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:node ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (node * 'a) option
                  val min_elt_exn : 'a t -> node * 'a
                  val max_elt : 'a t -> (node * 'a) option
                  val max_elt_exn : 'a t -> node * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:node -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:node -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:node -> data:'-> bool) -> int
                  val split :
                    'a t -> node -> 'a t * (node * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:node Base__.Maybe_bound.t ->
                    upper_bound:node Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:node ->
                    max:node ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:node -> max:node -> (node * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> node -> (node * 'a) option
                  val nth : 'a t -> int -> (node * 'a) option
                  val nth_exn : 'a t -> int -> node * 'a
                  val rank : 'a t -> node -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:node ->
                    ?keys_less_or_equal_to:node ->
                    'a t -> (node * 'a) Base__.Sequence.t
                  val obs :
                    node Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    node Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> node
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : node Bin_prot.Type_class.t
                               val bin_read_t : node Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> node)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 node Bin_prot.Type_class.reader
                               val bin_size_t : node Bin_prot.Size.sizer
                               val bin_write_t : node Bin_prot.Write.writer
                               val bin_writer_t :
                                 node Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 node -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = node
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (node, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (node, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(node -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(node -> bool) -> bool
                      val for_all : t -> f:(node -> bool) -> bool
                      val count : t -> f:(node -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(node -> 'sum) -> 'sum
                      val find : t -> f:(node -> bool) -> node option
                      val find_map : t -> f:(node -> 'a option) -> 'a option
                      val to_list : t -> node list
                      val to_array : t -> node array
                      val invariants : t -> bool
                      val mem : t -> node -> bool
                      val add : t -> node -> t
                      val remove : t -> node -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (node, node) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           node ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(node -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of node * node
                           | `Left of node
                           | `Right of node ] -> unit) ->
                        unit
                      val filter : t -> f:(node -> bool) -> t
                      val partition_tf : t -> f:(node -> bool) -> t * t
                      val elements : t -> node list
                      val min_elt : t -> node option
                      val min_elt_exn : t -> node
                      val max_elt : t -> node option
                      val max_elt_exn : t -> node
                      val choose : t -> node option
                      val choose_exn : t -> node
                      val split : t -> node -> t * node option * t
                      val group_by :
                        t -> equiv:(node -> node -> bool) -> t list
                      val find_exn : t -> f:(node -> bool) -> node
                      val find_index : t -> int -> node option
                      val nth : t -> int -> node option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node ->
                        t ->
                        t ->
                        (node, node)
                        Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(node -> 'data) ->
                        (node, 'data, comparator_witness) Core_kernel__.Map.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : node -> t
                      val union_list : t list -> t
                      val of_list : node list -> t
                      val of_array : node array -> t
                      val of_sorted_array : node array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : node array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node) -> t
                      val stable_dedup_list : node list -> node list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> node) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> node option) -> t
                      val of_tree : t -> t
                      val of_hash_set : node Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (node, 'a) Block.Table.hashtbl -> t
                      val of_map_keys :
                        (node, 'a, comparator_witness) Core_kernel__.Map.t ->
                        t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> node
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (node, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (node, comparator_witness)
                      Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(node -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(node -> bool) -> bool
                  val for_all : t -> f:(node -> bool) -> bool
                  val count : t -> f:(node -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(node -> 'sum) -> 'sum
                  val find : t -> f:(node -> bool) -> node option
                  val find_map : t -> f:(node -> 'a option) -> 'a option
                  val to_list : t -> node list
                  val to_array : t -> node array
                  val invariants : t -> bool
                  val mem : t -> node -> bool
                  val add : t -> node -> t
                  val remove : t -> node -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (node, node) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       node ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(node -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of node * node
                       | `Left of node
                       | `Right of node ] -> unit) ->
                    unit
                  val filter : t -> f:(node -> bool) -> t
                  val partition_tf : t -> f:(node -> bool) -> t * t
                  val elements : t -> node list
                  val min_elt : t -> node option
                  val min_elt_exn : t -> node
                  val max_elt : t -> node option
                  val max_elt_exn : t -> node
                  val choose : t -> node option
                  val choose_exn : t -> node
                  val split : t -> node -> t * node option * t
                  val group_by : t -> equiv:(node -> node -> bool) -> t list
                  val find_exn : t -> f:(node -> bool) -> node
                  val find_index : t -> int -> node option
                  val nth : t -> int -> node option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:node ->
                    ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:node ->
                    ?less_or_equal_to:node ->
                    t ->
                    t ->
                    (node, node) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(node -> 'data) ->
                    (node, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    node Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    node Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : node -> t
                  val union_list : t list -> t
                  val of_list : node list -> t
                  val of_array : node array -> t
                  val of_sorted_array : node array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : node array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> node) -> t
                  val stable_dedup_list : node list -> node list
                  val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : node Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (node, 'a) Block.Table.hashtbl -> t
                  val of_map_keys :
                    (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    node Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> node
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : node Bin_prot.Type_class.t
                               val bin_read_t : node Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> node)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 node Bin_prot.Type_class.reader
                               val bin_size_t : node Bin_prot.Size.sizer
                               val bin_write_t : node Bin_prot.Write.writer
                               val bin_writer_t :
                                 node Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 node -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              val compare : t -> t -> Core_kernel__.Import.int
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                t -> Ppx_hash_lib.Std.Hash.state
              val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : t Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Block.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = node
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> node -> Core_kernel__.Import.bool
                  val lookup : 'a t -> node -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> node -> 'a
                  val enqueue :
                    'a t -> node -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> node -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> node -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (node * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> node Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (node * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> node * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> node -> Core_kernel__.Import.unit
                  val replace : 'a t -> node -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> node -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:node -> data:'-> 'b) -> 'b
                end
            end
          module Edge :
            sig
              type t = edge
              type node = block
              type graph = cfg
              type label = edge
              val create : node -> node -> label -> t
              val label : t -> label
              val src : t -> node
              val dst : t -> node
              val mem : t -> graph -> bool
              val insert : t -> graph -> graph
              val update : t -> label -> graph -> graph
              val remove : t -> graph -> graph
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = edge
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_increasing_sequence :
                        (edge * 'a) Base__.Sequence.t ->
                        'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Node.Table.hashtbl -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:edge ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:edge -> data:'-> 'a t
                      val set : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val find_multi : 'a list t -> edge -> 'a list
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (edge, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : edge -> '-> 'a t
                  val of_alist :
                    (edge * 'a) list ->
                    [ `Duplicate_key of edge | `Ok of 'a t ]
                  val of_alist_or_error :
                    (edge * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (edge * 'a) list -> 'a t
                  val of_alist_multi : (edge * 'a) list -> 'a list t
                  val of_alist_fold :
                    (edge * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (edge * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge * 'a) -> 'a t
                  val of_increasing_sequence :
                    (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of edge | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn : (edge, 'a) Node.Table.hashtbl -> 'a t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:edge ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:edge -> data:'-> 'a t
                  val set : 'a t -> key:edge -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:edge -> data:'-> 'a list t
                  val remove_multi : 'a list t -> edge -> 'a list t
                  val find_multi : 'a list t -> edge -> 'a list
                  val change :
                    'a t -> edge -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> edge -> 'a option
                  val find_exn : 'a t -> edge -> 'a
                  val remove : 'a t -> edge -> 'a t
                  val mem : 'a t -> edge -> bool
                  val iter_keys : 'a t -> f:(edge -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:edge -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> edge list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (edge * 'a) list
                  val validate :
                    name:(edge -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (edge * 'a) option
                  val min_elt_exn : 'a t -> edge * 'a
                  val max_elt : 'a t -> (edge * 'a) option
                  val max_elt_exn : 'a t -> edge * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:edge -> data:'-> bool) -> int
                  val split :
                    'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:edge Base__.Maybe_bound.t ->
                    upper_bound:edge Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:edge ->
                    max:edge ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:edge -> max:edge -> (edge * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> edge -> (edge * 'a) option
                  val nth : 'a t -> int -> (edge * 'a) option
                  val nth_exn : 'a t -> int -> edge * 'a
                  val rank : 'a t -> edge -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:edge ->
                    ?keys_less_or_equal_to:edge ->
                    'a t -> (edge * 'a) Base__.Sequence.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = edge
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (edge, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (edge, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness) Core_kernel__.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> edge option) -> t
                      val of_tree : t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Node.Table.hashtbl -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness) Core_kernel__.Map.t ->
                        t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> edge
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (edge, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (edge, comparator_witness)
                      Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(edge -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(edge -> bool) -> bool
                  val for_all : t -> f:(edge -> bool) -> bool
                  val count : t -> f:(edge -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(edge -> 'sum) -> 'sum
                  val find : t -> f:(edge -> bool) -> edge option
                  val find_map : t -> f:(edge -> 'a option) -> 'a option
                  val to_list : t -> edge list
                  val to_array : t -> edge array
                  val invariants : t -> bool
                  val mem : t -> edge -> bool
                  val add : t -> edge -> t
                  val remove : t -> edge -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       edge ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(edge -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of edge * edge
                       | `Left of edge
                       | `Right of edge ] -> unit) ->
                    unit
                  val filter : t -> f:(edge -> bool) -> t
                  val partition_tf : t -> f:(edge -> bool) -> t * t
                  val elements : t -> edge list
                  val min_elt : t -> edge option
                  val min_elt_exn : t -> edge
                  val max_elt : t -> edge option
                  val max_elt_exn : t -> edge
                  val choose : t -> edge option
                  val choose_exn : t -> edge
                  val split : t -> edge -> t * edge option * t
                  val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                  val find_exn : t -> f:(edge -> bool) -> edge
                  val find_index : t -> int -> edge option
                  val nth : t -> int -> edge option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge ->
                    t ->
                    t ->
                    (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(edge -> 'data) ->
                    (edge, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : edge -> t
                  val union_list : t list -> t
                  val of_list : edge list -> t
                  val of_array : edge array -> t
                  val of_sorted_array : edge array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : edge array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge) -> t
                  val stable_dedup_list : edge list -> edge list
                  val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                  val of_map_keys :
                    (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              val compare : t -> t -> Core_kernel__.Import.int
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                t -> Ppx_hash_lib.Std.Hash.state
              val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : t Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = edge
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> edge -> Core_kernel__.Import.bool
                  val lookup : 'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> edge -> 'a
                  val enqueue :
                    'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> edge Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> edge * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                  val replace : 'a t -> edge -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                end
            end
          val empty : t
          val nodes : t -> node Regular.Std.seq
          val edges : t -> edge Regular.Std.seq
          val is_directed : bool
          val number_of_edges : t -> int
          val number_of_nodes : t -> int
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = cfg
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (cfg, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : cfg -> '-> 'a t
                  val of_alist :
                    (cfg * 'a) list ->
                    [ `Duplicate_key of cfg | `Ok of 'a t ]
                  val of_alist_or_error :
                    (cfg * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (cfg * 'a) list -> 'a t
                  val of_alist_multi : (cfg * 'a) list -> 'a list t
                  val of_alist_fold :
                    (cfg * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (cfg * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (cfg * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (cfg * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> cfg * 'a) -> 'a t
                  val of_increasing_sequence :
                    (cfg * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:cfg -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of cfg | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (cfg, 'a) Edge.Table.hashtbl -> 'a t
                  val gen :
                    cfg Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:cfg -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:cfg -> data:'-> 'a t
                  val set : 'a t -> key:cfg -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:cfg -> data:'-> 'a list t
                  val remove_multi : 'a list t -> cfg -> 'a list t
                  val find_multi : 'a list t -> cfg -> 'a list
                  val change :
                    'a t -> cfg -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> cfg -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> cfg -> 'a option
                  val find_exn : 'a t -> cfg -> 'a
                  val remove : 'a t -> cfg -> 'a t
                  val mem : 'a t -> cfg -> bool
                  val iter_keys : 'a t -> f:(cfg -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:cfg -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:cfg ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:cfg -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:cfg ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(cfg -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:cfg -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:cfg -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:cfg -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:cfg -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> cfg list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (cfg * 'a) list
                  val validate :
                    name:(cfg -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:cfg ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (cfg, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (cfg * 'a) option
                  val min_elt_exn : 'a t -> cfg * 'a
                  val max_elt : 'a t -> (cfg * 'a) option
                  val max_elt_exn : 'a t -> cfg * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:cfg -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:cfg -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:cfg -> data:'-> bool) -> int
                  val split : 'a t -> cfg -> 'a t * (cfg * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:cfg Base__.Maybe_bound.t ->
                    upper_bound:cfg Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:cfg ->
                    max:cfg ->
                    init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:cfg -> max:cfg -> (cfg * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> cfg -> (cfg * 'a) option
                  val nth : 'a t -> int -> (cfg * 'a) option
                  val nth_exn : 'a t -> int -> cfg * 'a
                  val rank : 'a t -> cfg -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:cfg ->
                    ?keys_less_or_equal_to:cfg ->
                    'a t -> (cfg * 'a) Base__.Sequence.t
                  val obs :
                    cfg Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    cfg Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cfg
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (cfg, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : cfg -> '-> 'a t
              val of_alist :
                (cfg * 'a) list -> [ `Duplicate_key of cfg | `Ok of 'a t ]
              val of_alist_or_error :
                (cfg * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (cfg * 'a) list -> 'a t
              val of_alist_multi : (cfg * 'a) list -> 'a list t
              val of_alist_fold :
                (cfg * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (cfg * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (cfg * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (cfg * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> cfg * 'a) -> 'a t
              val of_increasing_sequence :
                (cfg * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:cfg -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of cfg | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (cfg, 'a) Edge.Table.hashtbl -> 'a t
              val gen :
                cfg Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:cfg -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:cfg -> data:'-> 'a t
              val set : 'a t -> key:cfg -> data:'-> 'a t
              val add_multi : 'a list t -> key:cfg -> data:'-> 'a list t
              val remove_multi : 'a list t -> cfg -> 'a list t
              val find_multi : 'a list t -> cfg -> 'a list
              val change : 'a t -> cfg -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> cfg -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> cfg -> 'a option
              val find_exn : 'a t -> cfg -> 'a
              val remove : 'a t -> cfg -> 'a t
              val mem : 'a t -> cfg -> bool
              val iter_keys : 'a t -> f:(cfg -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:cfg -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:cfg ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:cfg -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:cfg ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(cfg -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:cfg -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:cfg -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:cfg -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:cfg -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> cfg list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (cfg * 'a) list
              val validate :
                name:(cfg -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:cfg ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (cfg, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (cfg * 'a) option
              val min_elt_exn : 'a t -> cfg * 'a
              val max_elt : 'a t -> (cfg * 'a) option
              val max_elt_exn : 'a t -> cfg * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:cfg -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:cfg -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:cfg -> data:'-> bool) -> int
              val split : 'a t -> cfg -> 'a t * (cfg * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:cfg Base__.Maybe_bound.t ->
                upper_bound:cfg Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:cfg ->
                max:cfg ->
                init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:cfg -> max:cfg -> (cfg * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> cfg -> (cfg * 'a) option
              val nth : 'a t -> int -> (cfg * 'a) option
              val nth_exn : 'a t -> int -> cfg * 'a
              val rank : 'a t -> cfg -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:cfg ->
                ?keys_less_or_equal_to:cfg ->
                'a t -> (cfg * 'a) Base__.Sequence.t
              val obs :
                cfg Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                cfg Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cfg
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : cfg Bin_prot.Type_class.t
                           val bin_read_t : cfg Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> cfg)
                             Bin_prot.Read.reader
                           val bin_reader_t : cfg Bin_prot.Type_class.reader
                           val bin_size_t : cfg Bin_prot.Size.sizer
                           val bin_write_t : cfg Bin_prot.Write.writer
                           val bin_writer_t : cfg Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> cfg -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = cfg
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (cfg, comparator_witness) Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (cfg, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(cfg -> unit) -> unit
                  val fold :
                    t -> init:'accum -> f:('accum -> cfg -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> cfg -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(cfg -> bool) -> bool
                  val for_all : t -> f:(cfg -> bool) -> bool
                  val count : t -> f:(cfg -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(cfg -> 'sum) -> 'sum
                  val find : t -> f:(cfg -> bool) -> cfg option
                  val find_map : t -> f:(cfg -> 'a option) -> 'a option
                  val to_list : t -> cfg list
                  val to_array : t -> cfg array
                  val invariants : t -> bool
                  val mem : t -> cfg -> bool
                  val add : t -> cfg -> t
                  val remove : t -> cfg -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (cfg, cfg) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       cfg -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(cfg -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of cfg * cfg | `Left of cfg | `Right of cfg ] ->
                       unit) ->
                    unit
                  val filter : t -> f:(cfg -> bool) -> t
                  val partition_tf : t -> f:(cfg -> bool) -> t * t
                  val elements : t -> cfg list
                  val min_elt : t -> cfg option
                  val min_elt_exn : t -> cfg
                  val max_elt : t -> cfg option
                  val max_elt_exn : t -> cfg
                  val choose : t -> cfg option
                  val choose_exn : t -> cfg
                  val split : t -> cfg -> t * cfg option * t
                  val group_by : t -> equiv:(cfg -> cfg -> bool) -> t list
                  val find_exn : t -> f:(cfg -> bool) -> cfg
                  val find_index : t -> int -> cfg option
                  val nth : t -> int -> cfg option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:cfg ->
                    ?less_or_equal_to:cfg -> t -> cfg Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:cfg ->
                    ?less_or_equal_to:cfg ->
                    t ->
                    t ->
                    (cfg, cfg) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(cfg -> 'data) ->
                    (cfg, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    cfg Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    cfg Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : cfg -> t
                  val union_list : t list -> t
                  val of_list : cfg list -> t
                  val of_array : cfg array -> t
                  val of_sorted_array : cfg array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : cfg array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> cfg) -> t
                  val stable_dedup_list : cfg list -> cfg list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> cfg) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> cfg option) -> t
                  val of_tree : t -> t
                  val of_hash_set : cfg Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (cfg, 'a) Edge.Table.hashtbl -> t
                  val of_map_keys :
                    (cfg, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    cfg Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> cfg
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (cfg, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (cfg, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(cfg -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> cfg -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> cfg -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(cfg -> bool) -> bool
              val for_all : t -> f:(cfg -> bool) -> bool
              val count : t -> f:(cfg -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(cfg -> 'sum) -> 'sum
              val find : t -> f:(cfg -> bool) -> cfg option
              val find_map : t -> f:(cfg -> 'a option) -> 'a option
              val to_list : t -> cfg list
              val to_array : t -> cfg array
              val invariants : t -> bool
              val mem : t -> cfg -> bool
              val add : t -> cfg -> t
              val remove : t -> cfg -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (cfg, cfg) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   cfg -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(cfg -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of cfg * cfg | `Left of cfg | `Right of cfg ] ->
                   unit) ->
                unit
              val filter : t -> f:(cfg -> bool) -> t
              val partition_tf : t -> f:(cfg -> bool) -> t * t
              val elements : t -> cfg list
              val min_elt : t -> cfg option
              val min_elt_exn : t -> cfg
              val max_elt : t -> cfg option
              val max_elt_exn : t -> cfg
              val choose : t -> cfg option
              val choose_exn : t -> cfg
              val split : t -> cfg -> t * cfg option * t
              val group_by : t -> equiv:(cfg -> cfg -> bool) -> t list
              val find_exn : t -> f:(cfg -> bool) -> cfg
              val find_index : t -> int -> cfg option
              val nth : t -> int -> cfg option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:cfg ->
                ?less_or_equal_to:cfg -> t -> cfg Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:cfg ->
                ?less_or_equal_to:cfg ->
                t ->
                t ->
                (cfg, cfg) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(cfg -> 'data) ->
                (cfg, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                cfg Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                cfg Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : cfg -> t
              val union_list : t list -> t
              val of_list : cfg list -> t
              val of_array : cfg array -> t
              val of_sorted_array : cfg array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : cfg array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> cfg) -> t
              val stable_dedup_list : cfg list -> cfg list
              val map : ('a, 'b) Base.Set.t -> f:('-> cfg) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> cfg option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : cfg Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (cfg, 'a) Edge.Table.hashtbl -> t
              val of_map_keys :
                (cfg, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                cfg Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cfg
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : cfg Bin_prot.Type_class.t
                           val bin_read_t : cfg Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> cfg)
                             Bin_prot.Read.reader
                           val bin_reader_t : cfg Bin_prot.Type_class.reader
                           val bin_size_t : cfg Bin_prot.Size.sizer
                           val bin_write_t : cfg Bin_prot.Write.writer
                           val bin_writer_t : cfg Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> cfg -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          val compare : t -> t -> Core_kernel__.Import.int
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = cfg
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> cfg -> Core_kernel__.Import.bool
              val lookup : 'a t -> cfg -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> cfg -> 'a
              val enqueue :
                'a t -> cfg -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> cfg -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> cfg -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> cfg -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (cfg * 'a) Core_kernel__.Import.option
              val keys : 'a t -> cfg Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (cfg * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> cfg * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> cfg -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> cfg -> Core_kernel__.Import.unit
              val replace : 'a t -> cfg -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> cfg -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:cfg -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:cfg -> data:'-> 'b) -> 'b
            end
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
        end
      module Callgraph :
        sig
          type t
          type node = tid
          type edge
          module Node :
            sig
              type t = node
              type graph = t
              type label = t
              type edge = edge
              val create : label -> label
              val label : label -> label
              val mem : label -> graph -> bool
              val succs : label -> graph -> label Regular.Std.seq
              val preds : label -> graph -> label Regular.Std.seq
              val inputs : label -> graph -> edge Regular.Std.seq
              val outputs : label -> graph -> edge Regular.Std.seq
              val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
              val insert : label -> graph -> graph
              val update : label -> label -> graph -> graph
              val remove : label -> graph -> graph
              val has_edge : label -> label -> graph -> bool
              val edge : label -> label -> graph -> edge option
              val ( >= ) : label -> label -> bool
              val ( <= ) : label -> label -> bool
              val ( = ) : label -> label -> bool
              val ( > ) : label -> label -> bool
              val ( < ) : label -> label -> bool
              val ( <> ) : label -> label -> bool
              val equal : label -> label -> bool
              val min : label -> label -> label
              val max : label -> label -> label
              val ascending : label -> label -> int
              val descending : label -> label -> int
              val between : label -> low:label -> high:label -> bool
              val clamp_exn : label -> min:label -> max:label -> label
              val clamp :
                label -> min:label -> max:label -> label Base__.Or_error.t
              type comparator_witness
              val comparator :
                (label, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:label Base__.Maybe_bound.t -> label Base__.Validate.check
              val validate_ubound :
                max:label Base__.Maybe_bound.t -> label Base__.Validate.check
              val validate_bound :
                min:label Base__.Maybe_bound.t ->
                max:label Base__.Maybe_bound.t -> label Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : label -> label -> bool
                  val ( <= ) : label -> label -> bool
                  val ( = ) : label -> label -> bool
                  val ( > ) : label -> label -> bool
                  val ( < ) : label -> label -> bool
                  val ( <> ) : label -> label -> bool
                  val equal : label -> label -> bool
                  val compare : label -> label -> int
                  val min : label -> label -> label
                  val max : label -> label -> label
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = label
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (label, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : label -> '-> 'a t
                      val of_alist :
                        (label * 'a) list ->
                        [ `Duplicate_key of label | `Ok of 'a t ]
                      val of_alist_or_error :
                        (label * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (label * 'a) list -> 'a t
                      val of_alist_multi : (label * 'a) list -> 'a list t
                      val of_alist_fold :
                        (label * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (label * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (label * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> label * 'a) -> 'a t
                      val of_increasing_sequence :
                        (label * 'a) Base__.Sequence.t ->
                        'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of label | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (label, 'a) Cfg.Table.hashtbl -> 'a t
                      val gen :
                        label Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:label ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:label -> data:'-> 'a t
                      val set : 'a t -> key:label -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:label -> data:'-> 'a list t
                      val remove_multi : 'a list t -> label -> 'a list t
                      val find_multi : 'a list t -> label -> 'a list
                      val change :
                        'a t -> label -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> label -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> label -> 'a option
                      val find_exn : 'a t -> label -> 'a
                      val remove : 'a t -> label -> 'a t
                      val mem : 'a t -> label -> bool
                      val iter_keys : 'a t -> f:(label -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:label -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:label ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:label ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:label -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:label -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:label ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:label -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> label list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (label * 'a) list
                      val validate :
                        name:(label -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:label ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (label, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (label * 'a) option
                      val min_elt_exn : 'a t -> label * 'a
                      val max_elt : 'a t -> (label * 'a) option
                      val max_elt_exn : 'a t -> label * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:label -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:label -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:label -> data:'-> bool) -> int
                      val split :
                        'a t -> label -> 'a t * (label * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:label Base__.Maybe_bound.t ->
                        upper_bound:label Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:label ->
                        max:label ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:label -> max:label -> (label * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> label -> (label * 'a) option
                      val nth : 'a t -> int -> (label * 'a) option
                      val nth_exn : 'a t -> int -> label * 'a
                      val rank : 'a t -> label -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:label ->
                        ?keys_less_or_equal_to:label ->
                        'a t -> (label * 'a) Base__.Sequence.t
                      val obs :
                        label Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        label Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> label
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (label, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : label -> '-> 'a t
                  val of_alist :
                    (label * 'a) list ->
                    [ `Duplicate_key of label | `Ok of 'a t ]
                  val of_alist_or_error :
                    (label * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (label * 'a) list -> 'a t
                  val of_alist_multi : (label * 'a) list -> 'a list t
                  val of_alist_fold :
                    (label * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (label * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (label * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> label * 'a) -> 'a t
                  val of_increasing_sequence :
                    (label * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of label | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn : (label, 'a) Cfg.Table.hashtbl -> 'a t
                  val gen :
                    label Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:label ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:label -> data:'-> 'a t
                  val set : 'a t -> key:label -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:label -> data:'-> 'a list t
                  val remove_multi : 'a list t -> label -> 'a list t
                  val find_multi : 'a list t -> label -> 'a list
                  val change :
                    'a t -> label -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> label -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> label -> 'a option
                  val find_exn : 'a t -> label -> 'a
                  val remove : 'a t -> label -> 'a t
                  val mem : 'a t -> label -> bool
                  val iter_keys : 'a t -> f:(label -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:label -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:label ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:label ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:label -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:label -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:label -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:label -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> label list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (label * 'a) list
                  val validate :
                    name:(label -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:label ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (label, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (label * 'a) option
                  val min_elt_exn : 'a t -> label * 'a
                  val max_elt : 'a t -> (label * 'a) option
                  val max_elt_exn : 'a t -> label * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:label -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:label -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:label -> data:'-> bool) -> int
                  val split :
                    'a t -> label -> 'a t * (label * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:label Base__.Maybe_bound.t ->
                    upper_bound:label Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:label ->
                    max:label ->
                    init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:label -> max:label -> (label * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> label -> (label * 'a) option
                  val nth : 'a t -> int -> (label * 'a) option
                  val nth_exn : 'a t -> int -> label * 'a
                  val rank : 'a t -> label -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:label ->
                    ?keys_less_or_equal_to:label ->
                    'a t -> (label * 'a) Base__.Sequence.t
                  val obs :
                    label Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    label Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> label
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : label Bin_prot.Type_class.t
                               val bin_read_t : label Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> label)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 label Bin_prot.Type_class.reader
                               val bin_size_t : label Bin_prot.Size.sizer
                               val bin_write_t : label Bin_prot.Write.writer
                               val bin_writer_t :
                                 label Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 label -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = label
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (label, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (label, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(label -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> label -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(label -> bool) -> bool
                      val for_all : t -> f:(label -> bool) -> bool
                      val count : t -> f:(label -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(label -> 'sum) -> 'sum
                      val find : t -> f:(label -> bool) -> label option
                      val find_map : t -> f:(label -> 'a option) -> 'a option
                      val to_list : t -> label list
                      val to_array : t -> label array
                      val invariants : t -> bool
                      val mem : t -> label -> bool
                      val add : t -> label -> t
                      val remove : t -> label -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (label, label) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           label ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(label -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of label * label
                           | `Left of label
                           | `Right of label ] -> unit) ->
                        unit
                      val filter : t -> f:(label -> bool) -> t
                      val partition_tf : t -> f:(label -> bool) -> t * t
                      val elements : t -> label list
                      val min_elt : t -> label option
                      val min_elt_exn : t -> label
                      val max_elt : t -> label option
                      val max_elt_exn : t -> label
                      val choose : t -> label option
                      val choose_exn : t -> label
                      val split : t -> label -> t * label option * t
                      val group_by :
                        t -> equiv:(label -> label -> bool) -> t list
                      val find_exn : t -> f:(label -> bool) -> label
                      val find_index : t -> int -> label option
                      val nth : t -> int -> label option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:label ->
                        ?less_or_equal_to:label ->
                        t -> label Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:label ->
                        ?less_or_equal_to:label ->
                        t ->
                        t ->
                        (label, label)
                        Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(label -> 'data) ->
                        (label, 'data, comparator_witness)
                        Core_kernel__.Map.t
                      val obs :
                        label Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        label Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : label -> t
                      val union_list : t list -> t
                      val of_list : label list -> t
                      val of_array : label array -> t
                      val of_sorted_array :
                        label array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : label array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> label) -> t
                      val stable_dedup_list : label list -> label list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> label) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> label option) -> t
                      val of_tree : t -> t
                      val of_hash_set : label Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (label, 'a) Cfg.Table.hashtbl -> t
                      val of_map_keys :
                        (label, 'a, comparator_witness) Core_kernel__.Map.t ->
                        t
                      val gen :
                        label Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> label
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (label, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (label, comparator_witness)
                      Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(label -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> label -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(label -> bool) -> bool
                  val for_all : t -> f:(label -> bool) -> bool
                  val count : t -> f:(label -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(label -> 'sum) -> 'sum
                  val find : t -> f:(label -> bool) -> label option
                  val find_map : t -> f:(label -> 'a option) -> 'a option
                  val to_list : t -> label list
                  val to_array : t -> label array
                  val invariants : t -> bool
                  val mem : t -> label -> bool
                  val add : t -> label -> t
                  val remove : t -> label -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (label, label) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       label ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(label -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of label * label
                       | `Left of label
                       | `Right of label ] -> unit) ->
                    unit
                  val filter : t -> f:(label -> bool) -> t
                  val partition_tf : t -> f:(label -> bool) -> t * t
                  val elements : t -> label list
                  val min_elt : t -> label option
                  val min_elt_exn : t -> label
                  val max_elt : t -> label option
                  val max_elt_exn : t -> label
                  val choose : t -> label option
                  val choose_exn : t -> label
                  val split : t -> label -> t * label option * t
                  val group_by :
                    t -> equiv:(label -> label -> bool) -> t list
                  val find_exn : t -> f:(label -> bool) -> label
                  val find_index : t -> int -> label option
                  val nth : t -> int -> label option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:label ->
                    ?less_or_equal_to:label -> t -> label Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:label ->
                    ?less_or_equal_to:label ->
                    t ->
                    t ->
                    (label, label)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(label -> 'data) ->
                    (label, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    label Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    label Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : label -> t
                  val union_list : t list -> t
                  val of_list : label list -> t
                  val of_array : label array -> t
                  val of_sorted_array : label array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : label array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> label) -> t
                  val stable_dedup_list : label list -> label list
                  val map : ('a, 'b) Base.Set.t -> f:('-> label) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> label option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : label Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (label, 'a) Cfg.Table.hashtbl -> t
                  val of_map_keys :
                    (label, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    label Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> label
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : label Bin_prot.Type_class.t
                               val bin_read_t : label Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> label)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 label Bin_prot.Type_class.reader
                               val bin_size_t : label Bin_prot.Size.sizer
                               val bin_write_t : label Bin_prot.Write.writer
                               val bin_writer_t :
                                 label Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 label -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              val compare : label -> label -> Core_kernel__.Import.int
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                label -> Ppx_hash_lib.Std.Hash.state
              val hash : label -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : label Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = label
                  type ('a, 'b) hashtbl = ('a, 'b) Cfg.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = label
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = label
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> label -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> label -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> label -> 'a
                  val enqueue :
                    'a t -> label -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> label -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> label -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> label -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (label * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> label Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (label * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> label * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> label -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> label -> Core_kernel__.Import.unit
                  val replace : 'a t -> label -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> label -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:label -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:label -> data:'-> 'b) -> 'b
                end
            end
          module Edge :
            sig
              type t = edge
              type node = tid
              type graph = Node.graph
              type label = jmp term list
              val create : node -> node -> label -> t
              val label : t -> label
              val src : t -> node
              val dst : t -> node
              val mem : t -> graph -> bool
              val insert : t -> graph -> graph
              val update : t -> label -> graph -> graph
              val remove : t -> graph -> graph
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = edge
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_increasing_sequence :
                        (edge * 'a) Base__.Sequence.t ->
                        'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Node.Table.hashtbl -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:edge ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:edge -> data:'-> 'a t
                      val set : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val find_multi : 'a list t -> edge -> 'a list
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (edge, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : edge -> '-> 'a t
                  val of_alist :
                    (edge * 'a) list ->
                    [ `Duplicate_key of edge | `Ok of 'a t ]
                  val of_alist_or_error :
                    (edge * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (edge * 'a) list -> 'a t
                  val of_alist_multi : (edge * 'a) list -> 'a list t
                  val of_alist_fold :
                    (edge * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (edge * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge * 'a) -> 'a t
                  val of_increasing_sequence :
                    (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of edge | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn : (edge, 'a) Node.Table.hashtbl -> 'a t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:edge ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:edge -> data:'-> 'a t
                  val set : 'a t -> key:edge -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:edge -> data:'-> 'a list t
                  val remove_multi : 'a list t -> edge -> 'a list t
                  val find_multi : 'a list t -> edge -> 'a list
                  val change :
                    'a t -> edge -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> edge -> 'a option
                  val find_exn : 'a t -> edge -> 'a
                  val remove : 'a t -> edge -> 'a t
                  val mem : 'a t -> edge -> bool
                  val iter_keys : 'a t -> f:(edge -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:edge -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> edge list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (edge * 'a) list
                  val validate :
                    name:(edge -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (edge * 'a) option
                  val min_elt_exn : 'a t -> edge * 'a
                  val max_elt : 'a t -> (edge * 'a) option
                  val max_elt_exn : 'a t -> edge * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:edge -> data:'-> bool) -> int
                  val split :
                    'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:edge Base__.Maybe_bound.t ->
                    upper_bound:edge Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:edge ->
                    max:edge ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:edge -> max:edge -> (edge * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> edge -> (edge * 'a) option
                  val nth : 'a t -> int -> (edge * 'a) option
                  val nth_exn : 'a t -> int -> edge * 'a
                  val rank : 'a t -> edge -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:edge ->
                    ?keys_less_or_equal_to:edge ->
                    'a t -> (edge * 'a) Base__.Sequence.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = edge
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (edge, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (edge, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness) Core_kernel__.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> edge option) -> t
                      val of_tree : t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Node.Table.hashtbl -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness) Core_kernel__.Map.t ->
                        t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> edge
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (edge, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (edge, comparator_witness)
                      Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(edge -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(edge -> bool) -> bool
                  val for_all : t -> f:(edge -> bool) -> bool
                  val count : t -> f:(edge -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(edge -> 'sum) -> 'sum
                  val find : t -> f:(edge -> bool) -> edge option
                  val find_map : t -> f:(edge -> 'a option) -> 'a option
                  val to_list : t -> edge list
                  val to_array : t -> edge array
                  val invariants : t -> bool
                  val mem : t -> edge -> bool
                  val add : t -> edge -> t
                  val remove : t -> edge -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       edge ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(edge -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of edge * edge
                       | `Left of edge
                       | `Right of edge ] -> unit) ->
                    unit
                  val filter : t -> f:(edge -> bool) -> t
                  val partition_tf : t -> f:(edge -> bool) -> t * t
                  val elements : t -> edge list
                  val min_elt : t -> edge option
                  val min_elt_exn : t -> edge
                  val max_elt : t -> edge option
                  val max_elt_exn : t -> edge
                  val choose : t -> edge option
                  val choose_exn : t -> edge
                  val split : t -> edge -> t * edge option * t
                  val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                  val find_exn : t -> f:(edge -> bool) -> edge
                  val find_index : t -> int -> edge option
                  val nth : t -> int -> edge option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge ->
                    t ->
                    t ->
                    (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(edge -> 'data) ->
                    (edge, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : edge -> t
                  val union_list : t list -> t
                  val of_list : edge list -> t
                  val of_array : edge array -> t
                  val of_sorted_array : edge array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : edge array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge) -> t
                  val stable_dedup_list : edge list -> edge list
                  val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                  val of_map_keys :
                    (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              val compare : t -> t -> Core_kernel__.Import.int
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                t -> Ppx_hash_lib.Std.Hash.state
              val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : t Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = edge
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> edge -> Core_kernel__.Import.bool
                  val lookup : 'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> edge -> 'a
                  val enqueue :
                    'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> edge Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> edge * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                  val replace : 'a t -> edge -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                end
            end
          val empty : t
          val nodes : t -> node Regular.Std.seq
          val edges : t -> edge Regular.Std.seq
          val is_directed : bool
          val number_of_edges : t -> int
          val number_of_nodes : t -> int
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = Edge.graph
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_increasing_sequence :
                    (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:Key.t ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
                  val set : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val find_multi : 'a list t -> Key.t -> 'a list
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Key.t
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Edge.graph
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          val compare : t -> t -> Core_kernel__.Import.int
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
        end
      module Ir :
        sig
          type t
          type edge
          type node
          module Edge :
            sig
              type t = edge
              type node = node
              type graph = t
              type label
              val create : node -> node -> label -> t
              val label : t -> label
              val src : t -> node
              val dst : t -> node
              val mem : t -> graph -> bool
              val insert : t -> graph -> graph
              val update : t -> label -> graph -> graph
              val remove : t -> graph -> graph
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = edge
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_increasing_sequence :
                        (edge * 'a) Base__.Sequence.t ->
                        'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Callgraph.Table.hashtbl -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:edge ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:edge -> data:'-> 'a t
                      val set : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val find_multi : 'a list t -> edge -> 'a list
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (edge, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : edge -> '-> 'a t
                  val of_alist :
                    (edge * 'a) list ->
                    [ `Duplicate_key of edge | `Ok of 'a t ]
                  val of_alist_or_error :
                    (edge * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (edge * 'a) list -> 'a t
                  val of_alist_multi : (edge * 'a) list -> 'a list t
                  val of_alist_fold :
                    (edge * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (edge * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge * 'a) -> 'a t
                  val of_increasing_sequence :
                    (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of edge | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (edge, 'a) Callgraph.Table.hashtbl -> 'a t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:edge ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:edge -> data:'-> 'a t
                  val set : 'a t -> key:edge -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:edge -> data:'-> 'a list t
                  val remove_multi : 'a list t -> edge -> 'a list t
                  val find_multi : 'a list t -> edge -> 'a list
                  val change :
                    'a t -> edge -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> edge -> 'a option
                  val find_exn : 'a t -> edge -> 'a
                  val remove : 'a t -> edge -> 'a t
                  val mem : 'a t -> edge -> bool
                  val iter_keys : 'a t -> f:(edge -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:edge -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> edge list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (edge * 'a) list
                  val validate :
                    name:(edge -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (edge * 'a) option
                  val min_elt_exn : 'a t -> edge * 'a
                  val max_elt : 'a t -> (edge * 'a) option
                  val max_elt_exn : 'a t -> edge * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:edge -> data:'-> bool) -> int
                  val split :
                    'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:edge Base__.Maybe_bound.t ->
                    upper_bound:edge Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:edge ->
                    max:edge ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:edge -> max:edge -> (edge * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> edge -> (edge * 'a) option
                  val nth : 'a t -> int -> (edge * 'a) option
                  val nth_exn : 'a t -> int -> edge * 'a
                  val rank : 'a t -> edge -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:edge ->
                    ?keys_less_or_equal_to:edge ->
                    'a t -> (edge * 'a) Base__.Sequence.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = edge
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (edge, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (edge, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness) Core_kernel__.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> edge option) -> t
                      val of_tree : t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Callgraph.Table.hashtbl -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness) Core_kernel__.Map.t ->
                        t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> edge
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (edge, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (edge, comparator_witness)
                      Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(edge -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(edge -> bool) -> bool
                  val for_all : t -> f:(edge -> bool) -> bool
                  val count : t -> f:(edge -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(edge -> 'sum) -> 'sum
                  val find : t -> f:(edge -> bool) -> edge option
                  val find_map : t -> f:(edge -> 'a option) -> 'a option
                  val to_list : t -> edge list
                  val to_array : t -> edge array
                  val invariants : t -> bool
                  val mem : t -> edge -> bool
                  val add : t -> edge -> t
                  val remove : t -> edge -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       edge ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(edge -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of edge * edge
                       | `Left of edge
                       | `Right of edge ] -> unit) ->
                    unit
                  val filter : t -> f:(edge -> bool) -> t
                  val partition_tf : t -> f:(edge -> bool) -> t * t
                  val elements : t -> edge list
                  val min_elt : t -> edge option
                  val min_elt_exn : t -> edge
                  val max_elt : t -> edge option
                  val max_elt_exn : t -> edge
                  val choose : t -> edge option
                  val choose_exn : t -> edge
                  val split : t -> edge -> t * edge option * t
                  val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                  val find_exn : t -> f:(edge -> bool) -> edge
                  val find_index : t -> int -> edge option
                  val nth : t -> int -> edge option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge ->
                    t ->
                    t ->
                    (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(edge -> 'data) ->
                    (edge, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : edge -> t
                  val union_list : t list -> t
                  val of_list : edge list -> t
                  val of_array : edge array -> t
                  val of_sorted_array : edge array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : edge array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge) -> t
                  val stable_dedup_list : edge list -> edge list
                  val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (edge, 'a) Callgraph.Table.hashtbl -> t
                  val of_map_keys :
                    (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              val compare : t -> t -> Core_kernel__.Import.int
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                t -> Ppx_hash_lib.Std.Hash.state
              val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : t Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Callgraph.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = edge
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> edge -> Core_kernel__.Import.bool
                  val lookup : 'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> edge -> 'a
                  val enqueue :
                    'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> edge Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> edge * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                  val replace : 'a t -> edge -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                end
              val jmps :
                [ `after | `before ] ->
                Bap.Std.Graphs.Ir.t ->
                graph -> Bap.Std.jmp Bap.Std.term Bap.Std.seq
              val edges :
                [ `after | `before ] ->
                Bap.Std.Graphs.Ir.t ->
                graph -> Bap.Std.Graphs.Ir.t Bap.Std.seq
              val jmp : Bap.Std.Graphs.Ir.t -> Bap.Std.jmp Bap.Std.term
              val tid : Bap.Std.Graphs.Ir.t -> Bap.Std.tid
              val cond : Bap.Std.Graphs.Ir.t -> graph -> Bap.Std.exp
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Formatter.t -> t -> unit
            end
          module Node :
            sig
              type t = node
              type graph = Edge.graph
              type label = blk term
              type edge = Edge.t
              val create : label -> t
              val label : t -> label
              val mem : t -> graph -> bool
              val succs : t -> graph -> t Regular.Std.seq
              val preds : t -> graph -> t Regular.Std.seq
              val inputs : t -> graph -> edge Regular.Std.seq
              val outputs : t -> graph -> edge Regular.Std.seq
              val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
              val insert : t -> graph -> graph
              val update : t -> label -> graph -> graph
              val remove : t -> graph -> graph
              val has_edge : t -> t -> graph -> bool
              val edge : t -> t -> graph -> edge option
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = node
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (node, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : node -> '-> 'a t
                      val of_alist :
                        (node * 'a) list ->
                        [ `Duplicate_key of node | `Ok of 'a t ]
                      val of_alist_or_error :
                        (node * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (node * 'a) list -> 'a t
                      val of_alist_multi : (node * 'a) list -> 'a list t
                      val of_alist_fold :
                        (node * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (node * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (node * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node * 'a) -> 'a t
                      val of_increasing_sequence :
                        (node * 'a) Base__.Sequence.t ->
                        'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of node | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (node, 'a) Edge.Table.hashtbl -> 'a t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:node ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:node -> data:'-> 'a t
                      val set : 'a t -> key:node -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:node -> data:'-> 'a list t
                      val remove_multi : 'a list t -> node -> 'a list t
                      val find_multi : 'a list t -> node -> 'a list
                      val change :
                        'a t -> node -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> node -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> node -> 'a option
                      val find_exn : 'a t -> node -> 'a
                      val remove : 'a t -> node -> 'a t
                      val mem : 'a t -> node -> bool
                      val iter_keys : 'a t -> f:(node -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:node -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:node -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:node -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:node -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> node list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (node * 'a) list
                      val validate :
                        name:(node -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (node * 'a) option
                      val min_elt_exn : 'a t -> node * 'a
                      val max_elt : 'a t -> (node * 'a) option
                      val max_elt_exn : 'a t -> node * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:node -> data:'-> bool) -> int
                      val split :
                        'a t -> node -> 'a t * (node * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:node Base__.Maybe_bound.t ->
                        upper_bound:node Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:node ->
                        max:node ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:node -> max:node -> (node * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> node -> (node * 'a) option
                      val nth : 'a t -> int -> (node * 'a) option
                      val nth_exn : 'a t -> int -> node * 'a
                      val rank : 'a t -> node -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:node ->
                        ?keys_less_or_equal_to:node ->
                        'a t -> (node * 'a) Base__.Sequence.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> node
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (node, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : node -> '-> 'a t
                  val of_alist :
                    (node * 'a) list ->
                    [ `Duplicate_key of node | `Ok of 'a t ]
                  val of_alist_or_error :
                    (node * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (node * 'a) list -> 'a t
                  val of_alist_multi : (node * 'a) list -> 'a list t
                  val of_alist_fold :
                    (node * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (node * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> node * 'a) -> 'a t
                  val of_increasing_sequence :
                    (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of node | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn : (node, 'a) Edge.Table.hashtbl -> 'a t
                  val gen :
                    node Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:node ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:node -> data:'-> 'a t
                  val set : 'a t -> key:node -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:node -> data:'-> 'a list t
                  val remove_multi : 'a list t -> node -> 'a list t
                  val find_multi : 'a list t -> node -> 'a list
                  val change :
                    'a t -> node -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> node -> 'a option
                  val find_exn : 'a t -> node -> 'a
                  val remove : 'a t -> node -> 'a t
                  val mem : 'a t -> node -> bool
                  val iter_keys : 'a t -> f:(node -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:node -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:node ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:node ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:node -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:node -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:node -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> node list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (node * 'a) list
                  val validate :
                    name:(node -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:node ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (node * 'a) option
                  val min_elt_exn : 'a t -> node * 'a
                  val max_elt : 'a t -> (node * 'a) option
                  val max_elt_exn : 'a t -> node * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:node -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:node -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:node -> data:'-> bool) -> int
                  val split :
                    'a t -> node -> 'a t * (node * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:node Base__.Maybe_bound.t ->
                    upper_bound:node Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:node ->
                    max:node ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:node -> max:node -> (node * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> node -> (node * 'a) option
                  val nth : 'a t -> int -> (node * 'a) option
                  val nth_exn : 'a t -> int -> node * 'a
                  val rank : 'a t -> node -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:node ->
                    ?keys_less_or_equal_to:node ->
                    'a t -> (node * 'a) Base__.Sequence.t
                  val obs :
                    node Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    node Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> node
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : node Bin_prot.Type_class.t
                               val bin_read_t : node Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> node)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 node Bin_prot.Type_class.reader
                               val bin_size_t : node Bin_prot.Size.sizer
                               val bin_write_t : node Bin_prot.Write.writer
                               val bin_writer_t :
                                 node Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 node -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = node
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (node, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (node, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(node -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(node -> bool) -> bool
                      val for_all : t -> f:(node -> bool) -> bool
                      val count : t -> f:(node -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(node -> 'sum) -> 'sum
                      val find : t -> f:(node -> bool) -> node option
                      val find_map : t -> f:(node -> 'a option) -> 'a option
                      val to_list : t -> node list
                      val to_array : t -> node array
                      val invariants : t -> bool
                      val mem : t -> node -> bool
                      val add : t -> node -> t
                      val remove : t -> node -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (node, node) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           node ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(node -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of node * node
                           | `Left of node
                           | `Right of node ] -> unit) ->
                        unit
                      val filter : t -> f:(node -> bool) -> t
                      val partition_tf : t -> f:(node -> bool) -> t * t
                      val elements : t -> node list
                      val min_elt : t -> node option
                      val min_elt_exn : t -> node
                      val max_elt : t -> node option
                      val max_elt_exn : t -> node
                      val choose : t -> node option
                      val choose_exn : t -> node
                      val split : t -> node -> t * node option * t
                      val group_by :
                        t -> equiv:(node -> node -> bool) -> t list
                      val find_exn : t -> f:(node -> bool) -> node
                      val find_index : t -> int -> node option
                      val nth : t -> int -> node option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node ->
                        t ->
                        t ->
                        (node, node)
                        Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(node -> 'data) ->
                        (node, 'data, comparator_witness) Core_kernel__.Map.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : node -> t
                      val union_list : t list -> t
                      val of_list : node list -> t
                      val of_array : node array -> t
                      val of_sorted_array : node array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : node array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node) -> t
                      val stable_dedup_list : node list -> node list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> node) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> node option) -> t
                      val of_tree : t -> t
                      val of_hash_set : node Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (node, 'a) Edge.Table.hashtbl -> t
                      val of_map_keys :
                        (node, 'a, comparator_witness) Core_kernel__.Map.t ->
                        t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> node
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (node, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (node, comparator_witness)
                      Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(node -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(node -> bool) -> bool
                  val for_all : t -> f:(node -> bool) -> bool
                  val count : t -> f:(node -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(node -> 'sum) -> 'sum
                  val find : t -> f:(node -> bool) -> node option
                  val find_map : t -> f:(node -> 'a option) -> 'a option
                  val to_list : t -> node list
                  val to_array : t -> node array
                  val invariants : t -> bool
                  val mem : t -> node -> bool
                  val add : t -> node -> t
                  val remove : t -> node -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (node, node) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       node ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(node -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of node * node
                       | `Left of node
                       | `Right of node ] -> unit) ->
                    unit
                  val filter : t -> f:(node -> bool) -> t
                  val partition_tf : t -> f:(node -> bool) -> t * t
                  val elements : t -> node list
                  val min_elt : t -> node option
                  val min_elt_exn : t -> node
                  val max_elt : t -> node option
                  val max_elt_exn : t -> node
                  val choose : t -> node option
                  val choose_exn : t -> node
                  val split : t -> node -> t * node option * t
                  val group_by : t -> equiv:(node -> node -> bool) -> t list
                  val find_exn : t -> f:(node -> bool) -> node
                  val find_index : t -> int -> node option
                  val nth : t -> int -> node option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:node ->
                    ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:node ->
                    ?less_or_equal_to:node ->
                    t ->
                    t ->
                    (node, node) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(node -> 'data) ->
                    (node, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    node Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    node Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : node -> t
                  val union_list : t list -> t
                  val of_list : node list -> t
                  val of_array : node array -> t
                  val of_sorted_array : node array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : node array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> node) -> t
                  val stable_dedup_list : node list -> node list
                  val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : node Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (node, 'a) Edge.Table.hashtbl -> t
                  val of_map_keys :
                    (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    node Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> node
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : node Bin_prot.Type_class.t
                               val bin_read_t : node Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> node)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 node Bin_prot.Type_class.reader
                               val bin_size_t : node Bin_prot.Size.sizer
                               val bin_write_t : node Bin_prot.Write.writer
                               val bin_writer_t :
                                 node Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 node -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              val compare : t -> t -> Core_kernel__.Import.int
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                t -> Ppx_hash_lib.Std.Hash.state
              val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : t Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = node
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> node -> Core_kernel__.Import.bool
                  val lookup : 'a t -> node -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> node -> 'a
                  val enqueue :
                    'a t -> node -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> node -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> node -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (node * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> node Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (node * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> node * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> node -> Core_kernel__.Import.unit
                  val replace : 'a t -> node -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> node -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:node -> data:'-> 'b) -> 'b
                end
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Formatter.t -> t -> unit
            end
          val empty : t
          val nodes : t -> node Regular.Std.seq
          val edges : t -> edge Regular.Std.seq
          val is_directed : bool
          val number_of_edges : t -> int
          val number_of_nodes : t -> int
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = Node.graph
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_increasing_sequence :
                    (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (Key.t, 'a) Node.Table.hashtbl -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:Key.t ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
                  val set : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val find_multi : 'a list t -> Key.t -> 'a list
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Key.t
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Node.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Node.graph
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (Elt.t, 'a) Node.Table.hashtbl -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Node.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          val compare : t -> t -> Core_kernel__.Import.int
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
        end
      module Tid :
        sig
          type t
          type node = tid
          type edge
          module Node :
            sig
              type t = node
              type graph = t
              type label = t
              type edge = edge
              val create : label -> label
              val label : label -> label
              val mem : label -> graph -> bool
              val succs : label -> graph -> label Regular.Std.seq
              val preds : label -> graph -> label Regular.Std.seq
              val inputs : label -> graph -> edge Regular.Std.seq
              val outputs : label -> graph -> edge Regular.Std.seq
              val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
              val insert : label -> graph -> graph
              val update : label -> label -> graph -> graph
              val remove : label -> graph -> graph
              val has_edge : label -> label -> graph -> bool
              val edge : label -> label -> graph -> edge option
              val ( >= ) : label -> label -> bool
              val ( <= ) : label -> label -> bool
              val ( = ) : label -> label -> bool
              val ( > ) : label -> label -> bool
              val ( < ) : label -> label -> bool
              val ( <> ) : label -> label -> bool
              val equal : label -> label -> bool
              val min : label -> label -> label
              val max : label -> label -> label
              val ascending : label -> label -> int
              val descending : label -> label -> int
              val between : label -> low:label -> high:label -> bool
              val clamp_exn : label -> min:label -> max:label -> label
              val clamp :
                label -> min:label -> max:label -> label Base__.Or_error.t
              type comparator_witness
              val comparator :
                (label, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:label Base__.Maybe_bound.t -> label Base__.Validate.check
              val validate_ubound :
                max:label Base__.Maybe_bound.t -> label Base__.Validate.check
              val validate_bound :
                min:label Base__.Maybe_bound.t ->
                max:label Base__.Maybe_bound.t -> label Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : label -> label -> bool
                  val ( <= ) : label -> label -> bool
                  val ( = ) : label -> label -> bool
                  val ( > ) : label -> label -> bool
                  val ( < ) : label -> label -> bool
                  val ( <> ) : label -> label -> bool
                  val equal : label -> label -> bool
                  val compare : label -> label -> int
                  val min : label -> label -> label
                  val max : label -> label -> label
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = label
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (label, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : label -> '-> 'a t
                      val of_alist :
                        (label * 'a) list ->
                        [ `Duplicate_key of label | `Ok of 'a t ]
                      val of_alist_or_error :
                        (label * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (label * 'a) list -> 'a t
                      val of_alist_multi : (label * 'a) list -> 'a list t
                      val of_alist_fold :
                        (label * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (label * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (label * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> label * 'a) -> 'a t
                      val of_increasing_sequence :
                        (label * 'a) Base__.Sequence.t ->
                        'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of label | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (label, 'a) Ir.Table.hashtbl -> 'a t
                      val gen :
                        label Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:label ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:label -> data:'-> 'a t
                      val set : 'a t -> key:label -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:label -> data:'-> 'a list t
                      val remove_multi : 'a list t -> label -> 'a list t
                      val find_multi : 'a list t -> label -> 'a list
                      val change :
                        'a t -> label -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> label -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> label -> 'a option
                      val find_exn : 'a t -> label -> 'a
                      val remove : 'a t -> label -> 'a t
                      val mem : 'a t -> label -> bool
                      val iter_keys : 'a t -> f:(label -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:label -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:label ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:label ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:label -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:label -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:label ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:label -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> label list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (label * 'a) list
                      val validate :
                        name:(label -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:label ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (label, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (label * 'a) option
                      val min_elt_exn : 'a t -> label * 'a
                      val max_elt : 'a t -> (label * 'a) option
                      val max_elt_exn : 'a t -> label * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:label -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:label -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:label -> data:'-> bool) -> int
                      val split :
                        'a t -> label -> 'a t * (label * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:label Base__.Maybe_bound.t ->
                        upper_bound:label Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:label ->
                        max:label ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:label -> max:label -> (label * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> label -> (label * 'a) option
                      val nth : 'a t -> int -> (label * 'a) option
                      val nth_exn : 'a t -> int -> label * 'a
                      val rank : 'a t -> label -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:label ->
                        ?keys_less_or_equal_to:label ->
                        'a t -> (label * 'a) Base__.Sequence.t
                      val obs :
                        label Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        label Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> label
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (label, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : label -> '-> 'a t
                  val of_alist :
                    (label * 'a) list ->
                    [ `Duplicate_key of label | `Ok of 'a t ]
                  val of_alist_or_error :
                    (label * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (label * 'a) list -> 'a t
                  val of_alist_multi : (label * 'a) list -> 'a list t
                  val of_alist_fold :
                    (label * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (label * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (label * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> label * 'a) -> 'a t
                  val of_increasing_sequence :
                    (label * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of label | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn : (label, 'a) Ir.Table.hashtbl -> 'a t
                  val gen :
                    label Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:label ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:label -> data:'-> 'a t
                  val set : 'a t -> key:label -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:label -> data:'-> 'a list t
                  val remove_multi : 'a list t -> label -> 'a list t
                  val find_multi : 'a list t -> label -> 'a list
                  val change :
                    'a t -> label -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> label -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> label -> 'a option
                  val find_exn : 'a t -> label -> 'a
                  val remove : 'a t -> label -> 'a t
                  val mem : 'a t -> label -> bool
                  val iter_keys : 'a t -> f:(label -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:label -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:label ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:label ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:label -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:label -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:label -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:label -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> label list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (label * 'a) list
                  val validate :
                    name:(label -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:label ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (label, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (label * 'a) option
                  val min_elt_exn : 'a t -> label * 'a
                  val max_elt : 'a t -> (label * 'a) option
                  val max_elt_exn : 'a t -> label * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:label -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:label -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:label -> data:'-> bool) -> int
                  val split :
                    'a t -> label -> 'a t * (label * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:label Base__.Maybe_bound.t ->
                    upper_bound:label Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:label ->
                    max:label ->
                    init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:label -> max:label -> (label * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> label -> (label * 'a) option
                  val nth : 'a t -> int -> (label * 'a) option
                  val nth_exn : 'a t -> int -> label * 'a
                  val rank : 'a t -> label -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:label ->
                    ?keys_less_or_equal_to:label ->
                    'a t -> (label * 'a) Base__.Sequence.t
                  val obs :
                    label Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    label Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> label
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : label Bin_prot.Type_class.t
                               val bin_read_t : label Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> label)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 label Bin_prot.Type_class.reader
                               val bin_size_t : label Bin_prot.Size.sizer
                               val bin_write_t : label Bin_prot.Write.writer
                               val bin_writer_t :
                                 label Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 label -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = label
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (label, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (label, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(label -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> label -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(label -> bool) -> bool
                      val for_all : t -> f:(label -> bool) -> bool
                      val count : t -> f:(label -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(label -> 'sum) -> 'sum
                      val find : t -> f:(label -> bool) -> label option
                      val find_map : t -> f:(label -> 'a option) -> 'a option
                      val to_list : t -> label list
                      val to_array : t -> label array
                      val invariants : t -> bool
                      val mem : t -> label -> bool
                      val add : t -> label -> t
                      val remove : t -> label -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (label, label) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           label ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(label -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of label * label
                           | `Left of label
                           | `Right of label ] -> unit) ->
                        unit
                      val filter : t -> f:(label -> bool) -> t
                      val partition_tf : t -> f:(label -> bool) -> t * t
                      val elements : t -> label list
                      val min_elt : t -> label option
                      val min_elt_exn : t -> label
                      val max_elt : t -> label option
                      val max_elt_exn : t -> label
                      val choose : t -> label option
                      val choose_exn : t -> label
                      val split : t -> label -> t * label option * t
                      val group_by :
                        t -> equiv:(label -> label -> bool) -> t list
                      val find_exn : t -> f:(label -> bool) -> label
                      val find_index : t -> int -> label option
                      val nth : t -> int -> label option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:label ->
                        ?less_or_equal_to:label ->
                        t -> label Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:label ->
                        ?less_or_equal_to:label ->
                        t ->
                        t ->
                        (label, label)
                        Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(label -> 'data) ->
                        (label, 'data, comparator_witness)
                        Core_kernel__.Map.t
                      val obs :
                        label Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        label Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : label -> t
                      val union_list : t list -> t
                      val of_list : label list -> t
                      val of_array : label array -> t
                      val of_sorted_array :
                        label array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : label array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> label) -> t
                      val stable_dedup_list : label list -> label list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> label) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> label option) -> t
                      val of_tree : t -> t
                      val of_hash_set : label Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys : (label, 'a) Ir.Table.hashtbl -> t
                      val of_map_keys :
                        (label, 'a, comparator_witness) Core_kernel__.Map.t ->
                        t
                      val gen :
                        label Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> label
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (label, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (label, comparator_witness)
                      Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(label -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> label -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(label -> bool) -> bool
                  val for_all : t -> f:(label -> bool) -> bool
                  val count : t -> f:(label -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(label -> 'sum) -> 'sum
                  val find : t -> f:(label -> bool) -> label option
                  val find_map : t -> f:(label -> 'a option) -> 'a option
                  val to_list : t -> label list
                  val to_array : t -> label array
                  val invariants : t -> bool
                  val mem : t -> label -> bool
                  val add : t -> label -> t
                  val remove : t -> label -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (label, label) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       label ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(label -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of label * label
                       | `Left of label
                       | `Right of label ] -> unit) ->
                    unit
                  val filter : t -> f:(label -> bool) -> t
                  val partition_tf : t -> f:(label -> bool) -> t * t
                  val elements : t -> label list
                  val min_elt : t -> label option
                  val min_elt_exn : t -> label
                  val max_elt : t -> label option
                  val max_elt_exn : t -> label
                  val choose : t -> label option
                  val choose_exn : t -> label
                  val split : t -> label -> t * label option * t
                  val group_by :
                    t -> equiv:(label -> label -> bool) -> t list
                  val find_exn : t -> f:(label -> bool) -> label
                  val find_index : t -> int -> label option
                  val nth : t -> int -> label option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:label ->
                    ?less_or_equal_to:label -> t -> label Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:label ->
                    ?less_or_equal_to:label ->
                    t ->
                    t ->
                    (label, label)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(label -> 'data) ->
                    (label, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    label Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    label Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : label -> t
                  val union_list : t list -> t
                  val of_list : label list -> t
                  val of_array : label array -> t
                  val of_sorted_array : label array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : label array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> label) -> t
                  val stable_dedup_list : label list -> label list
                  val map : ('a, 'b) Base.Set.t -> f:('-> label) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> label option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : label Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (label, 'a) Ir.Table.hashtbl -> t
                  val of_map_keys :
                    (label, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    label Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> label
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : label Bin_prot.Type_class.t
                               val bin_read_t : label Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> label)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 label Bin_prot.Type_class.reader
                               val bin_size_t : label Bin_prot.Size.sizer
                               val bin_write_t : label Bin_prot.Write.writer
                               val bin_writer_t :
                                 label Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 label -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              val compare : label -> label -> Core_kernel__.Import.int
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                label -> Ppx_hash_lib.Std.Hash.state
              val hash : label -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : label Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = label
                  type ('a, 'b) hashtbl = ('a, 'b) Ir.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = label
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = label
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> label -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> label -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> label -> 'a
                  val enqueue :
                    'a t -> label -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> label -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> label -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> label -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (label * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> label Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (label * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> label * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> label -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> label -> Core_kernel__.Import.unit
                  val replace : 'a t -> label -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> label -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:label -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:label -> data:'-> 'b) -> 'b
                end
            end
          module Edge :
            sig
              type t = edge
              type node = tid
              type graph = Node.graph
              type label = node
              val create : label -> label -> label -> t
              val label : t -> label
              val src : t -> label
              val dst : t -> label
              val mem : t -> graph -> bool
              val insert : t -> graph -> graph
              val update : t -> label -> graph -> graph
              val remove : t -> graph -> graph
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = edge
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Tree.t
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_increasing_sequence :
                        (edge * 'a) Base__.Sequence.t ->
                        'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Node.Table.hashtbl -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add :
                        'a t ->
                        key:edge ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:edge -> data:'-> 'a t
                      val set : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val find_multi : 'a list t -> edge -> 'a list
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type 'a t =
                      (edge, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : edge -> '-> 'a t
                  val of_alist :
                    (edge * 'a) list ->
                    [ `Duplicate_key of edge | `Ok of 'a t ]
                  val of_alist_or_error :
                    (edge * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (edge * 'a) list -> 'a t
                  val of_alist_multi : (edge * 'a) list -> 'a list t
                  val of_alist_fold :
                    (edge * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (edge * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge * 'a) -> 'a t
                  val of_increasing_sequence :
                    (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of edge | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn : (edge, 'a) Node.Table.hashtbl -> 'a t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:edge ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:edge -> data:'-> 'a t
                  val set : 'a t -> key:edge -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:edge -> data:'-> 'a list t
                  val remove_multi : 'a list t -> edge -> 'a list t
                  val find_multi : 'a list t -> edge -> 'a list
                  val change :
                    'a t -> edge -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> edge -> 'a option
                  val find_exn : 'a t -> edge -> 'a
                  val remove : 'a t -> edge -> 'a t
                  val mem : 'a t -> edge -> bool
                  val iter_keys : 'a t -> f:(edge -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:edge -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> edge list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (edge * 'a) list
                  val validate :
                    name:(edge -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (edge * 'a) option
                  val min_elt_exn : 'a t -> edge * 'a
                  val max_elt : 'a t -> (edge * 'a) option
                  val max_elt_exn : 'a t -> edge * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:edge -> data:'-> bool) -> int
                  val split :
                    'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:edge Base__.Maybe_bound.t ->
                    upper_bound:edge Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:edge ->
                    max:edge ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:edge -> max:edge -> (edge * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> edge -> (edge * 'a) option
                  val nth : 'a t -> int -> (edge * 'a) option
                  val nth_exn : 'a t -> int -> edge * 'a
                  val rank : 'a t -> edge -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:edge ->
                    ?keys_less_or_equal_to:edge ->
                    'a t -> (edge * 'a) Base__.Sequence.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = edge
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (edge, comparator_witness)
                          Core_kernel__.Set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (edge, comparator_witness)
                          Core_kernel__.Set_intf.Tree.Named.t
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named -> of_:named -> unit Base__.Or_error.t
                          val equal :
                            named -> named -> unit Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness) Core_kernel__.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                        f:('-> edge option) -> t
                      val of_tree : t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Node.Table.hashtbl -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness) Core_kernel__.Map.t ->
                        t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> edge
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    end
                  type t = (edge, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (edge, comparator_witness)
                      Core_kernel__.Set_intf.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(edge -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(edge -> bool) -> bool
                  val for_all : t -> f:(edge -> bool) -> bool
                  val count : t -> f:(edge -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(edge -> 'sum) -> 'sum
                  val find : t -> f:(edge -> bool) -> edge option
                  val find_map : t -> f:(edge -> 'a option) -> 'a option
                  val to_list : t -> edge list
                  val to_array : t -> edge array
                  val invariants : t -> bool
                  val mem : t -> edge -> bool
                  val add : t -> edge -> t
                  val remove : t -> edge -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       edge ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(edge -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of edge * edge
                       | `Left of edge
                       | `Right of edge ] -> unit) ->
                    unit
                  val filter : t -> f:(edge -> bool) -> t
                  val partition_tf : t -> f:(edge -> bool) -> t * t
                  val elements : t -> edge list
                  val min_elt : t -> edge option
                  val min_elt_exn : t -> edge
                  val max_elt : t -> edge option
                  val max_elt_exn : t -> edge
                  val choose : t -> edge option
                  val choose_exn : t -> edge
                  val split : t -> edge -> t * edge option * t
                  val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                  val find_exn : t -> f:(edge -> bool) -> edge
                  val find_index : t -> int -> edge option
                  val nth : t -> int -> edge option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge ->
                    t ->
                    t ->
                    (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(edge -> 'data) ->
                    (edge, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : edge -> t
                  val union_list : t list -> t
                  val of_list : edge list -> t
                  val of_array : edge array -> t
                  val of_sorted_array : edge array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : edge array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge) -> t
                  val stable_dedup_list : edge list -> edge list
                  val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                  val of_map_keys :
                    (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              val compare : t -> t -> Core_kernel__.Import.int
              val hash_fold_t :
                Ppx_hash_lib.Std.Hash.state ->
                t -> Ppx_hash_lib.Std.Hash.state
              val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              val hashable : t Core_kernel__.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'b t -> Ppx_sexp_conv_lib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val findi_and_call :
                    'b t ->
                    key ->
                    if_found:(key:key -> data:'-> 'c) ->
                    if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val find_multi : 'b list t -> key -> 'b list
                  module Provide_of_sexp :
                    functor
                      (Key : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> key
                             end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                  module Provide_of_sexp :
                    functor
                      (X : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                           end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = edge
                      val compare : t -> t -> int
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Ppx_sexp_conv_lib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'final)
                       Base__.Container_intf.Continue_or_stop.t) ->
                    finish:('accum -> 'final) -> 'final
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val max_elt :
                    'a t -> compare:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> edge -> Core_kernel__.Import.bool
                  val lookup : 'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> edge -> 'a
                  val enqueue :
                    'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> edge Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> edge * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                  val replace : 'a t -> edge -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                end
            end
          val empty : t
          val nodes : t -> node Regular.Std.seq
          val edges : t -> edge Regular.Std.seq
          val is_directed : bool
          val number_of_edges : t -> int
          val number_of_nodes : t -> int
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = Edge.graph
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_increasing_sequence :
                    (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:Key.t ->
                    data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
                  val set : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val find_multi : 'a list t -> Key.t -> 'a list
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Key.t
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Edge.graph
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          val compare : t -> t -> Core_kernel__.Import.int
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
        end
    end
  module Disasm :
    sig
      type t = Bap.Std.disasm
      val create : Bap.Std.cfg -> Bap.Std.Disasm.t
      val of_mem :
        ?backend:string ->
        ?brancher:Bap.Std.brancher ->
        ?rooter:Bap.Std.rooter ->
        Bap.Std.arch ->
        Bap.Std.mem -> Bap.Std.Disasm.t Core_kernel.Or_error.t
      val of_image :
        ?backend:string ->
        ?brancher:Bap.Std.brancher ->
        ?rooter:Bap.Std.rooter ->
        Bap.Std.image -> Bap.Std.Disasm.t Core_kernel.Or_error.t
      val of_file :
        ?backend:string ->
        ?brancher:Bap.Std.brancher ->
        ?rooter:Bap.Std.rooter ->
        ?loader:string -> string -> Bap.Std.Disasm.t Core_kernel.Or_error.t
      module With_exn :
        sig
          val of_mem :
            ?backend:string ->
            ?brancher:Bap.Std.brancher ->
            ?rooter:Bap.Std.rooter ->
            Bap.Std.arch -> Bap.Std.mem -> Bap.Std.Disasm.t
          val of_image :
            ?backend:string ->
            ?brancher:Bap.Std.brancher ->
            ?rooter:Bap.Std.rooter -> Bap.Std.image -> Bap.Std.Disasm.t
          val of_file :
            ?backend:string ->
            ?brancher:Bap.Std.brancher ->
            ?rooter:Bap.Std.rooter ->
            ?loader:string -> string -> Bap.Std.Disasm.t
        end
      val merge : Bap.Std.Disasm.t -> Bap.Std.Disasm.t -> Bap.Std.Disasm.t
      val insns :
        Bap.Std.Disasm.t -> (Bap.Std.mem * Bap.Std.insn) Bap.Std.seq
      val cfg : Bap.Std.Disasm.t -> Bap.Std.cfg
      val insn : Bap.Std.insn Bap.Std.tag
    end
  type symtab
  module Symtab :
    sig
      type t = Bap.Std.symtab
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      type fn = string * Bap.Std.block * Bap.Std.cfg
      val sexp_of_fn : fn -> Ppx_sexp_conv_lib.Sexp.t
      val empty : Bap.Std.Symtab.t
      val add_symbol :
        Bap.Std.Symtab.t -> Bap.Std.Symtab.fn -> Bap.Std.Symtab.t
      val remove : Bap.Std.Symtab.t -> Bap.Std.Symtab.fn -> Bap.Std.Symtab.t
      val find_by_name :
        Bap.Std.Symtab.t -> string -> Bap.Std.Symtab.fn option
      val find_by_start :
        Bap.Std.Symtab.t -> Bap.Std.addr -> Bap.Std.Symtab.fn option
      val owners : Bap.Std.Symtab.t -> Bap.Std.addr -> Bap.Std.Symtab.fn list
      val dominators :
        Bap.Std.Symtab.t -> Bap.Std.mem -> Bap.Std.Symtab.fn list
      val intersecting :
        Bap.Std.Symtab.t -> Bap.Std.mem -> Bap.Std.Symtab.fn list
      val to_sequence : Bap.Std.Symtab.t -> Bap.Std.Symtab.fn Bap.Std.seq
      val span : Bap.Std.Symtab.fn -> unit Bap.Std.memmap
    end
  type lifter =
      Bap.Std.mem ->
      Bap.Std.Disasm_expert.Basic.full_insn ->
      Bap.Std.bil Core_kernel.Or_error.t
  module type CPU =
    sig
      val gpr : Bap.Std.Var.Set.t
      val mem : Bap.Std.var
      val sp : Bap.Std.var
      val zf : Bap.Std.var
      val cf : Bap.Std.var
      val vf : Bap.Std.var
      val nf : Bap.Std.var
      val is_reg : Bap.Std.var -> bool
      val is_flag : Bap.Std.var -> bool
      val is_sp : Bap.Std.var -> bool
      val is_bp : Bap.Std.var -> bool
      val is_zf : Bap.Std.var -> bool
      val is_cf : Bap.Std.var -> bool
      val is_vf : Bap.Std.var -> bool
      val is_nf : Bap.Std.var -> bool
      val is_mem : Bap.Std.var -> bool
    end
  module type Target = sig module CPU : CPU val lift : Bap.Std.lifter end
  val target_of_arch : Bap.Std.arch -> (module Bap.Std.Target)
  val register_target : Bap.Std.arch -> (module Bap.Std.Target-> unit
  module Tid :
    sig
      type t = Bap.Std.tid
      val create : unit -> Bap.Std.Tid.t
      val set_name : Bap.Std.tid -> string -> unit
      val name : Bap.Std.tid -> string
      val from_string : string -> Bap.Std.tid Core_kernel.Or_error.t
      val from_string_exn : string -> Bap.Std.tid
      val ( !! ) : string -> Bap.Std.tid
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.tid
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Block.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Block.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Block.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Block.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Block.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Term :
    sig
      type 'a t = 'Bap.Std.term
      val clone : 'Bap.Std.Term.t -> 'Bap.Std.Term.t
      val same : 'Bap.Std.Term.t -> 'Bap.Std.Term.t -> bool
      val name : 'Bap.Std.Term.t -> string
      val tid : 'Bap.Std.Term.t -> Bap.Std.tid
      val length : ('a, 'b) Bap.Std.cls -> 'Bap.Std.Term.t -> int
      val find :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t option
      val find_exn :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t
      val update :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> 'Bap.Std.Term.t -> 'Bap.Std.Term.t
      val remove :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t
      val change :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t ->
        Bap.Std.tid ->
        ('Bap.Std.Term.t option -> 'Bap.Std.Term.t option) ->
        'Bap.Std.Term.t
      val enum :
        ?rev:bool ->
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> 'Bap.Std.Term.t Bap.Std.seq
      val to_sequence :
        ?rev:bool ->
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> 'Bap.Std.Term.t Bap.Std.seq
      val map :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t ->
        f:('Bap.Std.Term.t -> 'Bap.Std.Term.t) -> 'Bap.Std.Term.t
      val filter_map :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t ->
        f:('Bap.Std.Term.t -> 'Bap.Std.Term.t option) ->
        'Bap.Std.Term.t
      val concat_map :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t ->
        f:('Bap.Std.Term.t -> 'Bap.Std.Term.t list) -> 'Bap.Std.Term.t
      val filter :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t ->
        f:('Bap.Std.Term.t -> bool) -> 'Bap.Std.Term.t
      val first :
        ('a, 'b) Bap.Std.cls -> 'Bap.Std.Term.t -> 'Bap.Std.Term.t option
      val last :
        ('a, 'b) Bap.Std.cls -> 'Bap.Std.Term.t -> 'Bap.Std.Term.t option
      val next :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t option
      val prev :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t option
      val after :
        ('a, 'b) Bap.Std.cls ->
        ?rev:bool ->
        'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t Bap.Std.seq
      val before :
        ('a, 'b) Bap.Std.cls ->
        ?rev:bool ->
        'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t Bap.Std.seq
      val append :
        ('a, 'b) Bap.Std.cls ->
        ?after:Bap.Std.tid ->
        'Bap.Std.Term.t -> 'Bap.Std.Term.t -> 'Bap.Std.Term.t
      val prepend :
        ('a, 'b) Bap.Std.cls ->
        ?before:Bap.Std.tid ->
        'Bap.Std.Term.t -> 'Bap.Std.Term.t -> 'Bap.Std.Term.t
      val nth :
        ('a, 'b) Bap.Std.cls ->
        'Bap.Std.Term.t -> int -> 'Bap.Std.Term.t option
      val nth_exn :
        ('a, 'b) Bap.Std.cls -> 'Bap.Std.Term.t -> int -> 'Bap.Std.Term.t
      val set_attr :
        'Bap.Std.Term.t -> 'Bap.Std.tag -> '-> 'Bap.Std.Term.t
      val attrs : 'Bap.Std.Term.t -> Bap.Std.Dict.t
      val with_attrs :
        'Bap.Std.Term.t -> Bap.Std.Dict.t -> 'Bap.Std.Term.t
      val get_attr : 'Bap.Std.Term.t -> 'Bap.Std.tag -> 'b option
      val has_attr : 'Bap.Std.Term.t -> 'Bap.Std.tag -> bool
      val del_attr : 'Bap.Std.Term.t -> 'Bap.Std.tag -> 'Bap.Std.Term.t
      val origin : Bap.Std.tid Bap.Std.tag
      val synthetic : unit Bap.Std.tag
      val live : unit Bap.Std.tag
      val dead : unit Bap.Std.tag
      val visited : unit Bap.Std.tag
      val precondition : Bap.Std.exp Bap.Std.tag
      val invariant : Bap.Std.exp Bap.Std.tag
      val postcondition : Bap.Std.exp Bap.Std.tag
      class mapper :
        object
          val exps_stack : exp list
          val under_condition : bool
          method map_arg :
            Bap.Std.arg Bap.Std.term -> Bap.Std.arg Bap.Std.term
          method map_binop : binop -> Exp.t -> Exp.t -> Exp.t
          method map_blk :
            Bap.Std.blk Bap.Std.term -> Bap.Std.blk Bap.Std.term
          method map_cast : cast -> int -> Exp.t -> Exp.t
          method map_concat : Exp.t -> Exp.t -> Exp.t
          method map_def :
            Bap.Std.def Bap.Std.term -> Bap.Std.def Bap.Std.term
          method map_exp : Exp.t -> Exp.t
          method map_extract : hi:int -> lo:int -> Exp.t -> Exp.t
          method map_int : word -> Exp.t
          method map_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> Exp.t
          method map_jmp :
            Bap.Std.jmp Bap.Std.term -> Bap.Std.jmp Bap.Std.term
          method map_let : var -> exp:Exp.t -> body:Exp.t -> Exp.t
          method map_load :
            mem:Exp.t -> addr:Exp.t -> endian -> size -> Exp.t
          method map_phi :
            Bap.Std.phi Bap.Std.term -> Bap.Std.phi Bap.Std.term
          method map_store :
            mem:Exp.t -> addr:Exp.t -> exp:Exp.t -> endian -> size -> Exp.t
          method map_sub :
            Bap.Std.sub Bap.Std.term -> Bap.Std.sub Bap.Std.term
          method map_sym : var -> var
          method map_term :
            ('p, 't) Bap.Std.cls -> 'Bap.Std.term -> 'Bap.Std.term
          method map_unknown : Trie.String.Suffix.key -> typ -> Exp.t
          method map_unop : unop -> Exp.t -> Exp.t
          method map_var : var -> Exp.t
          method run :
            Bap.Std.program Bap.Std.term -> Bap.Std.program Bap.Std.term
        end
      class ['a] visitor :
        object
          val exps_stack : exp list
          val under_condition : bool
          method enter_arg : Bap.Std.arg Bap.Std.term -> '-> 'a
          method enter_binop : binop -> Exp.t -> Exp.t -> '-> 'a
          method enter_blk : Bap.Std.blk Bap.Std.term -> '-> 'a
          method enter_cast : cast -> int -> Exp.t -> '-> 'a
          method enter_concat : Exp.t -> Exp.t -> '-> 'a
          method enter_def : Bap.Std.def Bap.Std.term -> '-> 'a
          method enter_exp : Exp.t -> '-> 'a
          method enter_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
          method enter_int : word -> '-> 'a
          method enter_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
          method enter_jmp : Bap.Std.jmp Bap.Std.term -> '-> 'a
          method enter_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
          method enter_load :
            mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
          method enter_phi : Bap.Std.phi Bap.Std.term -> '-> 'a
          method enter_program : Bap.Std.program Bap.Std.term -> '-> 'a
          method enter_store :
            mem:Exp.t ->
            addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
          method enter_sub : Bap.Std.sub Bap.Std.term -> '-> 'a
          method enter_term :
            ('p, 't) Bap.Std.cls -> 'Bap.Std.term -> '-> 'a
          method enter_unknown : Trie.String.Suffix.key -> typ -> '-> 'a
          method enter_unop : unop -> Exp.t -> '-> 'a
          method enter_var : var -> '-> 'a
          method leave_arg : Bap.Std.arg Bap.Std.term -> '-> 'a
          method leave_binop : binop -> Exp.t -> Exp.t -> '-> 'a
          method leave_blk : Bap.Std.blk Bap.Std.term -> '-> 'a
          method leave_cast : cast -> int -> Exp.t -> '-> 'a
          method leave_concat : Exp.t -> Exp.t -> '-> 'a
          method leave_def : Bap.Std.def Bap.Std.term -> '-> 'a
          method leave_exp : Exp.t -> '-> 'a
          method leave_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
          method leave_int : word -> '-> 'a
          method leave_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
          method leave_jmp : Bap.Std.jmp Bap.Std.term -> '-> 'a
          method leave_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
          method leave_load :
            mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
          method leave_phi : Bap.Std.phi Bap.Std.term -> '-> 'a
          method leave_program : Bap.Std.program Bap.Std.term -> '-> 'a
          method leave_store :
            mem:Exp.t ->
            addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
          method leave_sub : Bap.Std.sub Bap.Std.term -> '-> 'a
          method leave_term :
            ('p, 't) Bap.Std.cls -> 'Bap.Std.term -> '-> 'a
          method leave_unknown : Trie.String.Suffix.key -> typ -> '-> 'a
          method leave_unop : unop -> Exp.t -> '-> 'a
          method leave_var : var -> '-> 'a
          method run : Bap.Std.program Bap.Std.term -> '-> 'a
          method visit_arg : Bap.Std.arg Bap.Std.term -> '-> 'a
          method visit_binop : binop -> Exp.t -> Exp.t -> '-> 'a
          method visit_blk : Bap.Std.blk Bap.Std.term -> '-> 'a
          method visit_cast : cast -> int -> Exp.t -> '-> 'a
          method visit_concat : Exp.t -> Exp.t -> '-> 'a
          method visit_def : Bap.Std.def Bap.Std.term -> '-> 'a
          method visit_exp : Exp.t -> '-> 'a
          method visit_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
          method visit_int : word -> '-> 'a
          method visit_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
          method visit_jmp : Bap.Std.jmp Bap.Std.term -> '-> 'a
          method visit_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
          method visit_load :
            mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
          method visit_phi : Bap.Std.phi Bap.Std.term -> '-> 'a
          method visit_store :
            mem:Exp.t ->
            addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
          method visit_sub : Bap.Std.sub Bap.Std.term -> '-> 'a
          method visit_term :
            ('p, 't) Bap.Std.cls -> 'Bap.Std.term -> '-> 'a
          method visit_unknown : Trie.String.Suffix.key -> typ -> '-> 'a
          method visit_unop : unop -> Exp.t -> '-> 'a
          method visit_var : var -> '-> 'a
        end
      val switch :
        ('p, 't) Bap.Std.cls ->
        program:(Bap.Std.program Bap.Std.term -> 'a) ->
        sub:(Bap.Std.sub Bap.Std.term -> 'a) ->
        arg:(Bap.Std.arg Bap.Std.term -> 'a) ->
        blk:(Bap.Std.blk Bap.Std.term -> 'a) ->
        phi:(Bap.Std.phi Bap.Std.term -> 'a) ->
        def:(Bap.Std.def Bap.Std.term -> 'a) ->
        jmp:(Bap.Std.jmp Bap.Std.term -> 'a) -> 'Bap.Std.term -> 'a
      val proj :
        ('p, 't) Bap.Std.cls ->
        ?program:(Bap.Std.program Bap.Std.term -> 'a option) ->
        ?sub:(Bap.Std.sub Bap.Std.term -> 'a option) ->
        ?arg:(Bap.Std.arg Bap.Std.term -> 'a option) ->
        ?blk:(Bap.Std.blk Bap.Std.term -> 'a option) ->
        ?phi:(Bap.Std.phi Bap.Std.term -> 'a option) ->
        ?def:(Bap.Std.def Bap.Std.term -> 'a option) ->
        ?jmp:(Bap.Std.jmp Bap.Std.term -> 'a option) ->
        'Bap.Std.term -> 'a option
      val cata :
        ('p, 't) Bap.Std.cls ->
        init:'->
        ?program:(Bap.Std.program Bap.Std.term -> 'a) ->
        ?sub:(Bap.Std.sub Bap.Std.term -> 'a) ->
        ?arg:(Bap.Std.arg Bap.Std.term -> 'a) ->
        ?blk:(Bap.Std.blk Bap.Std.term -> 'a) ->
        ?phi:(Bap.Std.phi Bap.Std.term -> 'a) ->
        ?def:(Bap.Std.def Bap.Std.term -> 'a) ->
        ?jmp:(Bap.Std.jmp Bap.Std.term -> 'a) -> 'Bap.Std.term -> 'a
    end
  module Program :
    sig
      type t = Bap.Std.program Bap.Std.term
      val create : ?tid:Bap.Std.tid -> unit -> Bap.Std.Program.t
      val lift : Bap.Std.symtab -> Bap.Std.program Bap.Std.term
      val to_graph : Bap.Std.Program.t -> Bap.Std.Graphs.Callgraph.t
      val lookup :
        ('a, 'b) Bap.Std.cls ->
        Bap.Std.Program.t -> Bap.Std.tid -> 'Bap.Std.term option
      val parent :
        ('a, 'b) Bap.Std.cls ->
        Bap.Std.Program.t -> Bap.Std.tid -> 'Bap.Std.term option
      module Builder :
        sig
          type t
          val create :
            ?tid:Bap.Std.tid ->
            ?subs:int -> unit -> Bap.Std.Program.Builder.t
          val add_sub :
            Bap.Std.Program.Builder.t -> Bap.Std.sub Bap.Std.term -> unit
          val result :
            Bap.Std.Program.Builder.t -> Bap.Std.program Bap.Std.term
        end
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Tid.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Tid.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Tid.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Tid.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Tid.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Sub :
    sig
      type t = Bap.Std.sub Bap.Std.term
      val create : ?tid:Bap.Std.tid -> ?name:string -> unit -> Bap.Std.Sub.t
      val lift : Bap.Std.block -> Bap.Std.cfg -> Bap.Std.sub Bap.Std.term
      val name : Bap.Std.Sub.t -> string
      val with_name : Bap.Std.Sub.t -> string -> Bap.Std.Sub.t
      val ssa : Bap.Std.Sub.t -> Bap.Std.Sub.t
      val is_ssa : Bap.Std.Sub.t -> bool
      val free_vars : Bap.Std.Sub.t -> Bap.Std.Var.Set.t
      val to_graph : Bap.Std.Sub.t -> Bap.Std.Graphs.Tid.t
      val to_cfg : Bap.Std.Sub.t -> Bap.Std.Graphs.Ir.t
      val of_cfg : Bap.Std.Graphs.Ir.t -> Bap.Std.Sub.t
      val aliases : string list Bap.Std.tag
      val const : unit Bap.Std.tag
      val pure : unit Bap.Std.tag
      val stub : unit Bap.Std.tag
      val extern : unit Bap.Std.tag
      val leaf : unit Bap.Std.tag
      val malloc : unit Bap.Std.tag
      val noreturn : unit Bap.Std.tag
      val returns_twice : unit Bap.Std.tag
      val nothrow : unit Bap.Std.tag
      val entry_point : unit Bap.Std.tag
      module Builder :
        sig
          type t
          val create :
            ?tid:Bap.Std.tid ->
            ?args:int ->
            ?blks:int -> ?name:string -> unit -> Bap.Std.Sub.Builder.t
          val add_blk :
            Bap.Std.Sub.Builder.t -> Bap.Std.blk Bap.Std.term -> unit
          val add_arg :
            Bap.Std.Sub.Builder.t -> Bap.Std.arg Bap.Std.term -> unit
          val result : Bap.Std.Sub.Builder.t -> Bap.Std.sub Bap.Std.term
        end
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Program.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Program.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Program.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Program.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Program.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Blk :
    sig
      type t = Bap.Std.blk Bap.Std.term
      type elt =
          [ `Def of Bap.Std.def Bap.Std.term
          | `Jmp of Bap.Std.jmp Bap.Std.term
          | `Phi of Bap.Std.phi Bap.Std.term ]
      val create : ?tid:Bap.Std.tid -> unit -> Bap.Std.Blk.t
      val lift :
        Bap.Std.cfg -> Bap.Std.block -> Bap.Std.blk Bap.Std.term list
      val from_insn : Bap.Std.insn -> Bap.Std.blk Bap.Std.term list
      val split_while :
        Bap.Std.Blk.t ->
        f:(Bap.Std.def Bap.Std.term -> bool) -> Bap.Std.Blk.t * Bap.Std.Blk.t
      val split_after :
        Bap.Std.Blk.t ->
        Bap.Std.def Bap.Std.term -> Bap.Std.Blk.t * Bap.Std.Blk.t
      val split_before :
        Bap.Std.Blk.t ->
        Bap.Std.def Bap.Std.term -> Bap.Std.Blk.t * Bap.Std.Blk.t
      val split_top : Bap.Std.Blk.t -> Bap.Std.Blk.t * Bap.Std.Blk.t
      val split_bot : Bap.Std.Blk.t -> Bap.Std.Blk.t * Bap.Std.Blk.t
      val elts : ?rev:bool -> Bap.Std.Blk.t -> Bap.Std.Blk.elt Bap.Std.seq
      val map_exp :
        ?skip:[ `def | `jmp | `phi ] list ->
        Bap.Std.Blk.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Blk.t
      val map_elts :
        ?phi:(Bap.Std.phi Bap.Std.term -> Bap.Std.phi Bap.Std.term) ->
        ?def:(Bap.Std.def Bap.Std.term -> Bap.Std.def Bap.Std.term) ->
        ?jmp:(Bap.Std.jmp Bap.Std.term -> Bap.Std.jmp Bap.Std.term) ->
        Bap.Std.blk Bap.Std.term -> Bap.Std.blk Bap.Std.term
      val substitute :
        ?skip:[ `def | `jmp | `phi ] list ->
        Bap.Std.Blk.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Blk.t
      val map_lhs :
        ?skip:[ `def | `phi ] list ->
        Bap.Std.Blk.t -> f:(Bap.Std.var -> Bap.Std.var) -> Bap.Std.Blk.t
      val find_var :
        Bap.Std.Blk.t ->
        Bap.Std.var ->
        [ `Def of Bap.Std.def Bap.Std.term | `Phi of Bap.Std.phi Bap.Std.term ]
        option
      val defines_var : Bap.Std.Blk.t -> Bap.Std.var -> bool
      val free_vars : Bap.Std.Blk.t -> Bap.Std.Var.Set.t
      val uses_var : Bap.Std.Blk.t -> Bap.Std.var -> bool
      val occurs : Bap.Std.Blk.t -> after:Bap.Std.tid -> Bap.Std.tid -> bool
      module Builder :
        sig
          type t
          val create :
            ?tid:Bap.Std.tid ->
            ?phis:int ->
            ?defs:int -> ?jmps:int -> unit -> Bap.Std.Blk.Builder.t
          val init :
            ?same_tid:bool ->
            ?copy_phis:bool ->
            ?copy_defs:bool ->
            ?copy_jmps:bool ->
            Bap.Std.blk Bap.Std.term -> Bap.Std.Blk.Builder.t
          val add_def :
            Bap.Std.Blk.Builder.t -> Bap.Std.def Bap.Std.term -> unit
          val add_jmp :
            Bap.Std.Blk.Builder.t -> Bap.Std.jmp Bap.Std.term -> unit
          val add_phi :
            Bap.Std.Blk.Builder.t -> Bap.Std.phi Bap.Std.term -> unit
          val add_elt : Bap.Std.Blk.Builder.t -> Bap.Std.Blk.elt -> unit
          val result : Bap.Std.Blk.Builder.t -> Bap.Std.blk Bap.Std.term
        end
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Sub.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Sub.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Sub.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Sub.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Sub.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Def :
    sig
      type t = Bap.Std.def Bap.Std.term
      val create :
        ?tid:Bap.Std.tid -> Bap.Std.var -> Bap.Std.exp -> Bap.Std.Def.t
      val lhs : Bap.Std.Def.t -> Bap.Std.var
      val rhs : Bap.Std.Def.t -> Bap.Std.exp
      val with_lhs : Bap.Std.Def.t -> Bap.Std.var -> Bap.Std.Def.t
      val with_rhs : Bap.Std.Def.t -> Bap.Std.exp -> Bap.Std.Def.t
      val map_exp :
        Bap.Std.Def.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Def.t
      val substitute :
        Bap.Std.Def.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Def.t
      val free_vars : Bap.Std.Def.t -> Bap.Std.Var.Set.t
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Blk.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Blk.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Blk.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Blk.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Blk.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Jmp :
    sig
      type t = Bap.Std.jmp Bap.Std.term
      val create :
        ?tid:Bap.Std.tid ->
        ?cond:Bap.Std.exp -> Bap.Std.jmp_kind -> Bap.Std.Jmp.t
      val create_call :
        ?tid:Bap.Std.tid ->
        ?cond:Bap.Std.exp -> Bap.Std.call -> Bap.Std.Jmp.t
      val create_goto :
        ?tid:Bap.Std.tid ->
        ?cond:Bap.Std.exp -> Bap.Std.label -> Bap.Std.Jmp.t
      val create_ret :
        ?tid:Bap.Std.tid ->
        ?cond:Bap.Std.exp -> Bap.Std.label -> Bap.Std.Jmp.t
      val create_int :
        ?tid:Bap.Std.tid ->
        ?cond:Bap.Std.exp -> int -> Bap.Std.tid -> Bap.Std.Jmp.t
      val kind : Bap.Std.Jmp.t -> Bap.Std.jmp_kind
      val cond : Bap.Std.Jmp.t -> Bap.Std.exp
      val exps : Bap.Std.Jmp.t -> Bap.Std.exp Bap.Std.seq
      val free_vars : Bap.Std.Jmp.t -> Bap.Std.Var.Set.t
      val map_exp :
        Bap.Std.Jmp.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Jmp.t
      val substitute :
        Bap.Std.Jmp.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Jmp.t
      val with_cond : Bap.Std.Jmp.t -> Bap.Std.exp -> Bap.Std.Jmp.t
      val with_kind : Bap.Std.Jmp.t -> Bap.Std.jmp_kind -> Bap.Std.Jmp.t
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Def.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Def.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Def.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Def.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Def.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Phi :
    sig
      type t = Bap.Std.phi Bap.Std.term
      val create :
        ?tid:Bap.Std.tid ->
        Bap.Std.var -> Bap.Std.tid -> Bap.Std.exp -> Bap.Std.Phi.t
      val of_list :
        ?tid:Bap.Std.tid ->
        Bap.Std.var -> (Bap.Std.tid * Bap.Std.exp) list -> Bap.Std.Phi.t
      val values : Bap.Std.Phi.t -> (Bap.Std.tid * Bap.Std.exp) Bap.Std.seq
      val free_vars : Bap.Std.Phi.t -> Bap.Std.Var.Set.t
      val lhs : Bap.Std.Phi.t -> Bap.Std.var
      val with_lhs : Bap.Std.Phi.t -> Bap.Std.var -> Bap.Std.Phi.t
      val map_exp :
        Bap.Std.Phi.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Phi.t
      val substitute :
        Bap.Std.Phi.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Phi.t
      val update :
        Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp -> Bap.Std.Phi.t
      val select : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp option
      val select_or_unknown : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp
      val remove : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.Phi.t
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Jmp.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Jmp.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Jmp.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Jmp.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Jmp.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Arg :
    sig
      type t = Bap.Std.arg Bap.Std.term
      val create :
        ?tid:Bap.Std.tid ->
        ?intent:Bap.Std.intent -> Bap.Std.var -> Bap.Std.exp -> Bap.Std.Arg.t
      val lhs : Bap.Std.Arg.t -> Bap.Std.var
      val rhs : Bap.Std.Arg.t -> Bap.Std.exp
      val intent : Bap.Std.Arg.t -> Bap.Std.intent option
      val with_intent : Bap.Std.Arg.t -> Bap.Std.intent -> Bap.Std.Arg.t
      val with_unknown_intent : Bap.Std.Arg.t -> Bap.Std.Arg.t
      val warn_unused : unit Bap.Std.tag
      val alloc_size : unit Bap.Std.tag
      val format : string Bap.Std.tag
      val nonnull : unit Bap.Std.tag
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Phi.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Phi.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Phi.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Phi.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Phi.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Call :
    sig
      type t = Bap.Std.call
      val create :
        ?return:Bap.Std.label ->
        target:Bap.Std.label -> unit -> Bap.Std.Call.t
      val target : Bap.Std.Call.t -> Bap.Std.label
      val return : Bap.Std.Call.t -> Bap.Std.label option
      val with_target : Bap.Std.Call.t -> Bap.Std.label -> Bap.Std.Call.t
      val with_return : Bap.Std.Call.t -> Bap.Std.label -> Bap.Std.Call.t
      val with_noreturn : Bap.Std.Call.t -> Bap.Std.Call.t
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.call
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Arg.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Arg.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Arg.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Arg.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Arg.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Label :
    sig
      type t = Bap.Std.label
      val create : unit -> Bap.Std.Label.t
      val direct : Bap.Std.tid -> Bap.Std.Label.t
      val indirect : Bap.Std.exp -> Bap.Std.Label.t
      val change :
        ?direct:(Bap.Std.tid -> Bap.Std.tid) ->
        ?indirect:(Bap.Std.exp -> Bap.Std.exp) ->
        Bap.Std.Label.t -> Bap.Std.Label.t
      val bin_t : t Core_kernel.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_t : Core_kernel.Bin_prot.Shape.t
      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      val clamp_exn : t -> min:t -> max:t -> t
      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
      type comparator_witness
      val validate_lbound :
        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_ubound :
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      val validate_bound :
        min:t Base__.Maybe_bound.t ->
        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
        end
      val comparator :
        (t, comparator_witness) Core_kernel__.Comparator.comparator
      module Map :
        sig
          module Key :
            sig
              type t = Bap.Std.label
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Map_intf.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_increasing_sequence :
                (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'a t -> 'a t
              val of_hashtbl_exn : (Key.t, 'a) Call.Table.hashtbl -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
              val set : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val find_multi : 'a list t -> Key.t -> 'a list
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (K : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
          val compare :
            ('-> '-> Core_kernel__.Import.int) ->
            'a t -> 'a t -> Core_kernel__.Import.int
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error : (Key.t * 'a) list -> 'a t Base__.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array : (Key.t * 'a) array -> 'a t Base__.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Key.t * 'a) -> 'a t
          val of_increasing_sequence :
            (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
          val of_iteri :
            iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
            [ `Duplicate_key of Key.t | `Ok of 'v t ]
          val of_tree : 'Tree.t -> 'a t
          val of_hashtbl_exn : (Key.t, 'a) Call.Table.hashtbl -> 'a t
          val gen :
            Key.t Core_kernel__.Quickcheck.Generator.t ->
            'Core_kernel__.Quickcheck.Generator.t ->
            'a t Core_kernel__.Quickcheck.Generator.t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add :
            'a t ->
            key:Key.t -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
          val add_exn : 'a t -> key:Key.t -> data:'-> 'a t
          val set : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val remove_multi : 'a list t -> Key.t -> 'a list t
          val find_multi : 'a list t -> Key.t -> 'a list
          val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
          val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
          val iter : 'a t -> f:('-> unit) -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold2 :
            'a t ->
            'b t ->
            init:'->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
               '-> 'c) ->
            'c
          val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
          val filter : 'a t -> f:('-> bool) -> 'a t
          val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val partition_mapi :
            'a t ->
            f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
            'b t * 'c t
          val partition_map :
            'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
          val partitioni_tf :
            'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
          val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist :
            ?key_order:[ `Decreasing | `Increasing ] ->
            'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'a t Base__.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
            Base__.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val append :
            lower_part:'a t ->
            upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
          val subrange :
            'a t ->
            lower_bound:Key.t Base__.Maybe_bound.t ->
            upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val nth_exn : 'a t -> int -> Key.t * 'a
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Base__.Sequence.t
          val obs :
            Key.t Core_kernel__.Quickcheck.Observer.t ->
            'Core_kernel__.Quickcheck.Observer.t ->
            'v t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Key.t Core_kernel__.Quickcheck.Shrinker.t ->
            'Core_kernel__.Quickcheck.Shrinker.t ->
            'v t Core_kernel__.Quickcheck.Shrinker.t
          module Provide_of_sexp :
            functor
              (Key : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                     end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : Key.t Bin_prot.Type_class.t
                       val bin_read_t : Key.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Key.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Key.t Bin_prot.Type_class.reader
                       val bin_size_t : Key.t Bin_prot.Size.sizer
                       val bin_write_t : Key.t Bin_prot.Write.writer
                       val bin_writer_t : Key.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
                val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
              end
          module Provide_hash :
            functor
              (Key : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Key.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  (Ppx_hash_lib.Std.Hash.state ->
                   '-> Ppx_hash_lib.Std.Hash.state) ->
                  Ppx_hash_lib.Std.Hash.state ->
                  'a t -> Ppx_hash_lib.Std.Hash.state
              end
          val t_of_sexp :
            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
          val sexp_of_t :
            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = Map.Key.t
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              type comparator_witness = Map.Key.comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
            end
          module Tree :
            sig
              type t =
                  (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (Elt.t, comparator_witness)
                  Core_kernel__.Set_intf.Tree.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (Elt.t, 'a) Call.Table.hashtbl -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
            end
          type t = (Elt.t, comparator_witness) Base.Set.t
          val compare : t -> t -> Core_kernel__.Import.int
          type named =
              (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val fold_result :
            t ->
            init:'accum ->
            f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val is_subset : t -> of_:t -> bool
          val subset : t -> t -> bool
          module Named :
            sig
              val is_subset : named -> of_:named -> unit Base__.Or_error.t
              val equal : named -> named -> unit Base__.Or_error.t
            end
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
            finish:('-> 'final) -> 'final
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val nth : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
          val merge_to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t ->
            t ->
            t ->
            (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
            Base__.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
          val obs :
            Elt.t Core_kernel__.Quickcheck.Observer.t ->
            t Core_kernel__.Quickcheck.Observer.t
          val shrinker :
            Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
            t Core_kernel__.Quickcheck.Shrinker.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Base__.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val of_increasing_iterator_unchecked :
            len:int -> f:(int -> Elt.t) -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
          val filter_map : ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
          val of_hashtbl_keys : (Elt.t, 'a) Call.Table.hashtbl -> t
          val of_map_keys :
            (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
          val gen :
            Elt.t Core_kernel__.Quickcheck.Generator.t ->
            t Core_kernel__.Quickcheck.Generator.t
          module Provide_of_sexp :
            functor
              (Elt : sig
                       val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                     end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (Elt : sig
                       val bin_t : Elt.t Bin_prot.Type_class.t
                       val bin_read_t : Elt.t Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> Elt.t)
                         Bin_prot.Read.reader
                       val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                       val bin_size_t : Elt.t Bin_prot.Size.sizer
                       val bin_write_t : Elt.t Bin_prot.Write.writer
                       val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                val bin_shape_t : Bin_prot.Shape.t
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_t : t Bin_prot.Type_class.t
              end
          module Provide_hash :
            functor
              (Elt : sig
                       val hash_fold_t :
                         Base__.Hash.state -> Elt.t -> Base__.Hash.state
                     end->
              sig
                val hash_fold_t :
                  Ppx_hash_lib.Std.Hash.state ->
                  t -> Ppx_hash_lib.Std.Hash.state
                val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
              end
          val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      val hash_fold_t :
        Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
      val hashable : t Core_kernel__.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Call.Table.hashtbl
          type 'b t = (key, 'b) hashtbl
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'b t -> Ppx_sexp_conv_lib.Sexp.t
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
          val invariant :
            'Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
          val create :
            (key, 'b, unit -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            (key, 'b,
             (key * 'b) list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            (key, 'b, (key * 'b) list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            (key, 'b list, (key * 'b) list -> 'b list t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_mapped :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key :
            (key, 'r,
             get_key:('-> key) ->
             'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            (key, 'r,
             get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val group :
            (key, 'b,
             get_key:('-> key) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> 'b t)
            Core_kernel__.Hashtbl_intf.create_options_without_hashable
          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
          val clear : 'a t -> unit
          val copy : 'b t -> 'b t
          val fold :
            'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
          val iter_keys : 'a t -> f:(key -> unit) -> unit
          val iter : 'b t -> f:('-> unit) -> unit
          val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
          val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val exists : 'b t -> f:('-> bool) -> bool
          val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
          val for_all : 'b t -> f:('-> bool) -> bool
          val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
          val count : 'b t -> f:('-> bool) -> int
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val remove : 'a t -> key -> unit
          val set : 'b t -> key:key -> data:'-> unit
          val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
          val add_exn : 'b t -> key:key -> data:'-> unit
          val change : 'b t -> key -> f:('b option -> 'b option) -> unit
          val update : 'b t -> key -> f:('b option -> 'b) -> unit
          val map : 'b t -> f:('-> 'c) -> 'c t
          val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
          val filter_map : 'b t -> f:('-> 'c option) -> 'c t
          val filter_mapi :
            'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
          val filter : 'b t -> f:('-> bool) -> 'b t
          val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
          val partition_map :
            'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
          val partition_mapi :
            'b t ->
            f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            'c t * 'd t
          val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
          val partitioni_tf :
            'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
          val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
          val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
          val find : 'b t -> key -> 'b option
          val find_exn : 'b t -> key -> 'b
          val find_and_call :
            'b t ->
            key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
          val findi_and_call :
            'b t ->
            key ->
            if_found:(key:key -> data:'-> 'c) ->
            if_not_found:(key -> 'c) -> 'c
          val find_and_remove : 'b t -> key -> 'b option
          val merge :
            'a t ->
            'b t ->
            f:(key:key ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          type 'a merge_into_action = Remove | Set_to of 'a
          val merge_into :
            src:'a t ->
            dst:'b t ->
            f:(key:key -> '-> 'b option -> 'b merge_into_action) -> unit
          val keys : 'a t -> key list
          val data : 'b t -> 'b list
          val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
          val filter_inplace : 'b t -> f:('-> bool) -> unit
          val filteri_inplace :
            'b t -> f:(key:key -> data:'-> bool) -> unit
          val map_inplace : 'b t -> f:('-> 'b) -> unit
          val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
          val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
          val filter_mapi_inplace :
            'b t -> f:(key:key -> data:'-> 'b option) -> unit
          val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
          val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : 'b t -> (key * 'b) list
          val validate :
            name:(key -> Trie.String.Suffix.key) ->
            'Base__.Validate.check -> 'b t Base__.Validate.check
          val incr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val decr : ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
          val add_multi : 'b list t -> key:key -> data:'-> unit
          val remove_multi : 'a list t -> key -> unit
          val find_multi : 'b list t -> key -> 'b list
          module Provide_of_sexp :
            functor
              (Key : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key end->
              sig
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
              end
          module Provide_bin_io :
            functor
              (Key : sig
                       val bin_t : key Bin_prot.Type_class.t
                       val bin_read_t : key Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> key)
                         Bin_prot.Read.reader
                       val bin_reader_t : key Bin_prot.Type_class.reader
                       val bin_size_t : key Bin_prot.Size.sizer
                       val bin_write_t : key Bin_prot.Write.writer
                       val bin_writer_t : key Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end->
              sig
                val bin_t :
                  'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                val bin_read_t :
                  'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Bin_prot.Read.reader ->
                  (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                val bin_reader_t :
                  'Bin_prot.Type_class.reader ->
                  'a t Bin_prot.Type_class.reader
                val bin_size_t :
                  'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                val bin_write_t :
                  'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                val bin_writer_t :
                  'Bin_prot.Type_class.writer ->
                  'a t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              end
          val t_of_sexp :
            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
          val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type t = elt Core_kernel__.Hash_set.t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          val of_list :
            ('a, elt list -> t)
            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
          module Provide_of_sexp :
            functor
              (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end->
              sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
          module Provide_bin_io :
            functor
              (X : sig
                     val bin_t : elt Bin_prot.Type_class.t
                     val bin_read_t : elt Bin_prot.Read.reader
                     val __bin_read_t__ :
                       (Core_kernel__.Import.int -> elt) Bin_prot.Read.reader
                     val bin_reader_t : elt Bin_prot.Type_class.reader
                     val bin_size_t : elt Bin_prot.Size.sizer
                     val bin_write_t : elt Bin_prot.Write.writer
                     val bin_writer_t : elt Bin_prot.Type_class.writer
                     val bin_shape_t : Bin_prot.Shape.t
                   end->
              sig
                val bin_t : t Bin_prot.Type_class.t
                val bin_read_t : t Bin_prot.Read.reader
                val __bin_read_t__ :
                  (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                val bin_reader_t : t Bin_prot.Type_class.reader
                val bin_size_t : t Bin_prot.Size.sizer
                val bin_write_t : t Bin_prot.Write.writer
                val bin_writer_t : t Bin_prot.Type_class.writer
                val bin_shape_t : Bin_prot.Shape.t
              end
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_shape_t : Bin_prot.Shape.t
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = Hash_set.elt
              val compare : t -> t -> int
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val hash : t -> int
            end
          type 'a t
          val sexp_of_t :
            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
            'a t -> Ppx_sexp_conv_lib.Sexp.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '->
               ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
            finish:('accum -> 'final) -> 'final
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
          val invariant : 'a t -> Core_kernel__.Import.unit
          val create :
            ?growth_allowed:Core_kernel__.Import.bool ->
            ?size:Core_kernel__.Import.int ->
            Core_kernel__.Import.unit -> 'a t
          val clear : 'a t -> Core_kernel__.Import.unit
          val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
          val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val lookup_and_move_to_back :
            'a t -> Key.t -> 'Core_kernel__.Import.option
          val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
          val first : 'a t -> 'Core_kernel__.Import.option
          val first_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val keys : 'a t -> Key.t Core_kernel__.Import.list
          val dequeue : 'a t -> 'Core_kernel__.Import.option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key :
            'a t -> (Key.t * 'a) Core_kernel__.Import.option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all :
            'a t ->
            f:('-> Core_kernel__.Import.unit) -> Core_kernel__.Import.unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> Core_kernel__.Import.unit
          val iteri :
            'a t ->
            f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
            Core_kernel__.Import.unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
    end
  module Source :
    sig
      type 'a t = 'Core_kernel.Or_error.t Bap_future.Std.stream
      type 'a source = 'Bap.Std.Source.t
      module Factory :
        sig
          module type S =
            sig
              type t
              val list : unit -> string list
              val find :
                string ->
                Bap.Std.Source.Factory.S.t Bap.Std.Source.source option
              val register :
                string ->
                Bap.Std.Source.Factory.S.t Bap.Std.Source.source -> unit
            end
          module Make :
            functor (T : Core_kernel.T->
              sig
                type t = T.t
                val list : unit -> Trie.String.Suffix.key list
                val find : Trie.String.Suffix.key -> t source option
                val register : Trie.String.Suffix.key -> t source -> unit
              end
        end
    end
  module Taint :
    sig
      type t = Bap.Std.tid
      type set = Bap.Std.Tid.Set.t
      val bin_set : set Core_kernel.Bin_prot.Type_class.t
      val bin_read_set : set Core_kernel.Bin_prot.Read.reader
      val __bin_read_set__ : (int -> set) Core_kernel.Bin_prot.Read.reader
      val bin_reader_set : set Core_kernel.Bin_prot.Type_class.reader
      val bin_size_set : set Core_kernel.Bin_prot.Size.sizer
      val bin_write_set : set Core_kernel.Bin_prot.Write.writer
      val bin_writer_set : set Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_set : Core_kernel.Bin_prot.Shape.t
      val compare_set : set -> set -> int
      val set_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> set
      val sexp_of_set : set -> Ppx_sexp_conv_lib.Sexp.t
      type map = Bap.Std.Taint.set Bap.Std.Var.Map.t
      val bin_map : map Core_kernel.Bin_prot.Type_class.t
      val bin_read_map : map Core_kernel.Bin_prot.Read.reader
      val __bin_read_map__ : (int -> map) Core_kernel.Bin_prot.Read.reader
      val bin_reader_map : map Core_kernel.Bin_prot.Type_class.reader
      val bin_size_map : map Core_kernel.Bin_prot.Size.sizer
      val bin_write_map : map Core_kernel.Bin_prot.Write.writer
      val bin_writer_map : map Core_kernel.Bin_prot.Type_class.writer
      val bin_shape_map : Core_kernel.Bin_prot.Shape.t
      val compare_map : map -> map -> int
      val map_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> map
      val sexp_of_map : map -> Ppx_sexp_conv_lib.Sexp.t
      val reg : Bap.Std.Taint.t Bap.Std.tag
      val ptr : Bap.Std.Taint.t Bap.Std.tag
      val regs : Bap.Std.Taint.map Bap.Std.tag
      val ptrs : Bap.Std.Taint.map Bap.Std.tag
      val merge : Bap.Std.Taint.map -> Bap.Std.Taint.map -> Bap.Std.Taint.map
      class context :
        object ('a)
          method all_taints : Bap.Std.Taint.set
          method ptr_taints : Bap.Std.addr -> Bap.Std.Taint.set
          method reg_taints : Bap.Std.Bil.result -> Bap.Std.Taint.set
          method taint_ptr :
            Bap.Std.addr -> Bap.Std.size -> Bap.Std.Taint.set -> 'a
          method taint_reg : Bap.Std.Bil.result -> Bap.Std.Taint.set -> 'a
        end
      module type S =
        sig
          type ('a, 'e) state
          module Expi :
            sig
              type ('a, 'e) state = ('a, 'e) state
              type 'a u = (unit, 'a) state
              type 'a r = (Bil.result, 'a) state
              module M : sig type ('a, 'e) t = ('a, 'e) state end
              module Eval :
                sig
                  class type ['a, 'r] semantics =
                    ['a, 'r] Eval.T2(M).semantics
                  class type virtual ['a, 'r, 's] domain =
                    ['a, 'r, 's] Eval.T2(M).domain
                  class type virtual ['a, 'r, 's] eff =
                    ['a, 'r, 's] Eval.T2(M).eff
                  class virtual ['a, 'r, 's] t :
                    object
                      method division_by_zero : unit -> ('r, 'a) state
                      method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                      method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                      method eval_concat : exp -> exp -> ('r, 'a) M.t
                      method eval_exp : exp -> ('r, 'a) M.t
                      method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                      method eval_int : word -> ('r, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                      method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                      method eval_load :
                        mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                      method eval_unop : unop -> exp -> ('r, 'a) M.t
                      method eval_var : var -> ('r, 'a) M.t
                      method virtual load : '-> addr -> ('r, 'a) M.t
                      method virtual lookup : var -> ('r, 'a) M.t
                      method private virtual storage_of_value :
                        '-> ('s option, 'a) M.t
                      method virtual store :
                        '-> addr -> word -> ('r, 'a) M.t
                      method type_error : type_error -> ('r, 'a) state
                      method private virtual undefined : ('r, 'a) M.t
                      method virtual update : var -> '-> (unit, 'a) M.t
                      method private virtual value_of_word :
                        word -> ('r, 'a) M.t
                      method private virtual word_of_value :
                        '-> (word option, 'a) M.t
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Expi.context
                  method division_by_zero : unit -> 'a r
                  method empty : Bil.storage
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method load : Bil.storage -> addr -> 'a r
                  method lookup : var -> 'a r
                  method store : Bil.storage -> addr -> word -> 'a r
                  method type_error : type_error -> 'a r
                  method undefined_addr : addr -> 'a r
                  method undefined_var : var -> 'a r
                  method update : var -> Bil.result -> 'a u
                end
            end
          class ['a] propagator :
            object
              constraint 'a =
                < all_taints : set; bindings : (var * Bil.result) seq;
                  create_storage : Bil.storage -> 'a * Bil.result;
                  create_undefined : 'a * Bil.result;
                  create_word : word -> 'a * Bil.result;
                  lookup : var -> Bil.result option;
                  ptr_taints : addr -> set; reg_taints : Bil.result -> set;
                  taint_ptr : addr -> size -> set -> 'a;
                  taint_reg : Bil.result -> set -> 'a;
                  update : var -> Bil.result -> 'a; .. >
              method division_by_zero : unit -> 'Expi.r
              method empty : Bil.storage
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method load : Bil.storage -> addr -> 'Expi.r
              method lookup : var -> 'Expi.r
              method store : Bil.storage -> addr -> word -> 'Expi.r
              method type_error : type_error -> 'Expi.r
              method undefined_addr : addr -> 'Expi.r
              method undefined_var : var -> 'Expi.r
              method update : var -> Bil.result -> 'Expi.u
            end
        end
      module Make :
        functor (M : Monads.Std.Monad.State.S2->
          sig
            type ('a, 'e) state = ('a, 'e) M.t
            module Expi :
              sig
                type ('a, 'e) state = ('a, 'e) M.t
                type 'a u = (unit, 'a) state
                type 'a r = (Bil.result, 'a) state
                module M : sig type ('a, 'e) t = ('a, 'e) state end
                module Eval :
                  sig
                    class type ['a, 'r] semantics =
                      ['a, 'r] Eval.T2(M).semantics
                    class type virtual ['a, 'r, 's] domain =
                      ['a, 'r, 's] Eval.T2(M).domain
                    class type virtual ['a, 'r, 's] eff =
                      ['a, 'r, 's] Eval.T2(M).eff
                    class virtual ['a, 'r, 's] t :
                      object
                        method division_by_zero : unit -> ('r, 'a) state
                        method eval_binop :
                          binop -> exp -> exp -> ('r, 'a) M.t
                        method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                        method eval_concat : exp -> exp -> ('r, 'a) M.t
                        method eval_exp : exp -> ('r, 'a) M.t
                        method eval_extract :
                          int -> int -> exp -> ('r, 'a) M.t
                        method eval_int : word -> ('r, 'a) M.t
                        method eval_ite :
                          cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                        method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                        method eval_load :
                          mem:exp ->
                          addr:exp -> endian -> size -> ('r, 'a) M.t
                        method eval_store :
                          mem:exp ->
                          addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                        method eval_unknown :
                          Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                        method eval_unop : unop -> exp -> ('r, 'a) M.t
                        method eval_var : var -> ('r, 'a) M.t
                        method virtual load : '-> addr -> ('r, 'a) M.t
                        method virtual lookup : var -> ('r, 'a) M.t
                        method private virtual storage_of_value :
                          '-> ('s option, 'a) M.t
                        method virtual store :
                          '-> addr -> word -> ('r, 'a) M.t
                        method type_error : type_error -> ('r, 'a) state
                        method private virtual undefined : ('r, 'a) M.t
                        method virtual update : var -> '-> (unit, 'a) M.t
                        method private virtual value_of_word :
                          word -> ('r, 'a) M.t
                        method private virtual word_of_value :
                          '-> (word option, 'a) M.t
                      end
                  end
                class ['a] t :
                  object
                    constraint 'a = #Expi.context
                    method division_by_zero : unit -> 'a r
                    method empty : Bil.storage
                    method eval_binop :
                      binop -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_cast :
                      cast -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                    method eval_exp : exp -> (Bil.result, 'a) M.t
                    method eval_extract :
                      int -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_int : word -> (Bil.result, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                    method eval_let :
                      var -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_load :
                      mem:exp ->
                      addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_store :
                      mem:exp ->
                      addr:exp ->
                      exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                    method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                    method eval_var : var -> (Bil.result, 'a) M.t
                    method load : Bil.storage -> addr -> 'a r
                    method lookup : var -> 'a r
                    method store : Bil.storage -> addr -> word -> 'a r
                    method type_error : type_error -> 'a r
                    method undefined_addr : addr -> 'a r
                    method undefined_var : var -> 'a r
                    method update : var -> Bil.result -> 'a u
                  end
              end
            class ['a] propagator :
              object
                constraint 'a =
                  < all_taints : set; bindings : (var * Bil.result) seq;
                    create_storage : Bil.storage -> 'a * Bil.result;
                    create_undefined : 'a * Bil.result;
                    create_word : word -> 'a * Bil.result;
                    lookup : var -> Bil.result option;
                    ptr_taints : addr -> set; reg_taints : Bil.result -> set;
                    taint_ptr : addr -> size -> set -> 'a;
                    taint_reg : Bil.result -> set -> 'a;
                    update : var -> Bil.result -> 'a; .. >
                method division_by_zero : unit -> 'Expi.r
                method empty : Bil.storage
                method eval_binop :
                  binop -> exp -> exp -> (Bil.result, 'a) M.t
                method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
                method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                method eval_exp : exp -> (Bil.result, 'a) M.t
                method eval_extract :
                  int -> int -> exp -> (Bil.result, 'a) M.t
                method eval_int : word -> (Bil.result, 'a) M.t
                method eval_ite :
                  cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                method eval_load :
                  mem:exp ->
                  addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                method eval_store :
                  mem:exp ->
                  addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                method eval_unknown :
                  Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                method eval_var : var -> (Bil.result, 'a) M.t
                method load : Bil.storage -> addr -> 'Expi.r
                method lookup : var -> 'Expi.r
                method store : Bil.storage -> addr -> word -> 'Expi.r
                method type_error : type_error -> 'Expi.r
                method undefined_addr : addr -> 'Expi.r
                method undefined_var : var -> 'Expi.r
                method update : var -> Bil.result -> 'Expi.u
              end
          end
      type ('a, 'e) state = ('a, 'e) Biri.state
      module Expi :
        sig
          type ('a, 'e) state = ('a, 'e) Biri.state
          type 'a u = (unit, 'a) state
          type 'a r = (Bil.result, 'a) state
          module M : sig type ('a, 'e) t = ('a, 'e) state end
          module Eval :
            sig
              class type ['a, 'r] semantics = ['a, 'r] Eval.T2(M).semantics
              class type virtual ['a, 'r, 's] domain =
                ['a, 'r, 's] Eval.T2(M).domain
              class type virtual ['a, 'r, 's] eff =
                ['a, 'r, 's] Eval.T2(M).eff
              class virtual ['a, 'r, 's] t :
                object
                  method division_by_zero : unit -> ('r, 'a) state
                  method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                  method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                  method eval_concat : exp -> exp -> ('r, 'a) M.t
                  method eval_exp : exp -> ('r, 'a) M.t
                  method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                  method eval_int : word -> ('r, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                  method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                  method eval_load :
                    mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                  method eval_unop : unop -> exp -> ('r, 'a) M.t
                  method eval_var : var -> ('r, 'a) M.t
                  method virtual load : '-> addr -> ('r, 'a) M.t
                  method virtual lookup : var -> ('r, 'a) M.t
                  method private virtual storage_of_value :
                    '-> ('s option, 'a) M.t
                  method virtual store : '-> addr -> word -> ('r, 'a) M.t
                  method type_error : type_error -> ('r, 'a) state
                  method private virtual undefined : ('r, 'a) M.t
                  method virtual update : var -> '-> (unit, 'a) M.t
                  method private virtual value_of_word : word -> ('r, 'a) M.t
                  method private virtual word_of_value :
                    '-> (word option, 'a) M.t
                end
            end
          class ['a] t :
            object
              constraint 'a = #Expi.context
              method division_by_zero : unit -> 'a r
              method empty : Bil.storage
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method load : Bil.storage -> addr -> 'a r
              method lookup : var -> 'a r
              method store : Bil.storage -> addr -> word -> 'a r
              method type_error : type_error -> 'a r
              method undefined_addr : addr -> 'a r
              method undefined_var : var -> 'a r
              method update : var -> Bil.result -> 'a u
            end
        end
      class ['a] propagator :
        object
          constraint 'a =
            < all_taints : set; bindings : (var * Bil.result) seq;
              create_storage : Bil.storage -> 'a * Bil.result;
              create_undefined : 'a * Bil.result;
              create_word : word -> 'a * Bil.result;
              lookup : var -> Bil.result option; ptr_taints : addr -> set;
              reg_taints : Bil.result -> set;
              taint_ptr : addr -> size -> set -> 'a;
              taint_reg : Bil.result -> set -> 'a;
              update : var -> Bil.result -> 'a; .. >
          method division_by_zero : unit -> 'Expi.r
          method empty : Bil.storage
          method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
          method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
          method eval_exp : exp -> (Bil.result, 'a) M.t
          method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
          method eval_int : word -> (Bil.result, 'a) M.t
          method eval_ite :
            cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
          method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_load :
            mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_store :
            mem:exp ->
            addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_unknown :
            Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
          method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
          method eval_var : var -> (Bil.result, 'a) M.t
          method load : Bil.storage -> addr -> 'Expi.r
          method lookup : var -> 'Expi.r
          method store : Bil.storage -> addr -> word -> 'Expi.r
          method type_error : type_error -> 'Expi.r
          method undefined_addr : addr -> 'Expi.r
          method undefined_var : var -> 'Expi.r
          method update : var -> Bil.result -> 'Expi.u
        end
      val pp_set : Bap.Std.Taint.set Regular.Std.printer
      val pp_map : Bap.Std.Taint.map Regular.Std.printer
      module Map :
        sig
          type t = map
          val bin_t : t Core_kernel.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Bin_prot.Shape.t
          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Formatter.t -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = map
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (map, 'a, comparator_witness)
                      Core_kernel__.Map_intf.Tree.t
                  val empty : 'a t
                  val singleton : map -> '-> 'a t
                  val of_alist :
                    (map * 'a) list ->
                    [ `Duplicate_key of map | `Ok of 'a t ]
                  val of_alist_or_error :
                    (map * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (map * 'a) list -> 'a t
                  val of_alist_multi : (map * 'a) list -> 'a list t
                  val of_alist_fold :
                    (map * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (map * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (map * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (map * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> map * 'a) -> 'a t
                  val of_increasing_sequence :
                    (map * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                  val of_iteri :
                    iteri:(f:(key:map -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of map | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn : (map, 'a) Label.Table.hashtbl -> 'a t
                  val gen :
                    map Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add :
                    'a t ->
                    key:map -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                  val add_exn : 'a t -> key:map -> data:'-> 'a t
                  val set : 'a t -> key:map -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:map -> data:'-> 'a list t
                  val remove_multi : 'a list t -> map -> 'a list t
                  val find_multi : 'a list t -> map -> 'a list
                  val change :
                    'a t -> map -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> map -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> map -> 'a option
                  val find_exn : 'a t -> map -> 'a
                  val remove : 'a t -> map -> 'a t
                  val mem : 'a t -> map -> bool
                  val iter_keys : 'a t -> f:(map -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:map -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:map ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:map -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:map ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(map -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:map -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:map -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:map -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:map -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> map list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (map * 'a) list
                  val validate :
                    name:(map -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:map ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (map, 'a) Base__.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (map * 'a) option
                  val min_elt_exn : 'a t -> map * 'a
                  val max_elt : 'a t -> (map * 'a) option
                  val max_elt_exn : 'a t -> map * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:map -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:map -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:map -> data:'-> bool) -> int
                  val split : 'a t -> map -> 'a t * (map * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:map Base__.Maybe_bound.t ->
                    upper_bound:map Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:map ->
                    max:map ->
                    init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:map -> max:map -> (map * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> map -> (map * 'a) option
                  val nth : 'a t -> int -> (map * 'a) option
                  val nth_exn : 'a t -> int -> map * 'a
                  val rank : 'a t -> map -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:map ->
                    ?keys_less_or_equal_to:map ->
                    'a t -> (map * 'a) Base__.Sequence.t
                  val obs :
                    map Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    map Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> map
                           end->
                      sig
                        val t_of_sexp :
                          (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                          Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                    Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                    'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type 'a t =
                  (map, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : map -> '-> 'a t
              val of_alist :
                (map * 'a) list -> [ `Duplicate_key of map | `Ok of 'a t ]
              val of_alist_or_error :
                (map * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (map * 'a) list -> 'a t
              val of_alist_multi : (map * 'a) list -> 'a list t
              val of_alist_fold :
                (map * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (map * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (map * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (map * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> map * 'a) -> 'a t
              val of_increasing_sequence :
                (map * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
              val of_iteri :
                iteri:(f:(key:map -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of map | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn : (map, 'a) Label.Table.hashtbl -> 'a t
              val gen :
                map Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add :
                'a t ->
                key:map -> data:'-> 'a t Base__.Map_intf.Or_duplicate.t
              val add_exn : 'a t -> key:map -> data:'-> 'a t
              val set : 'a t -> key:map -> data:'-> 'a t
              val add_multi : 'a list t -> key:map -> data:'-> 'a list t
              val remove_multi : 'a list t -> map -> 'a list t
              val find_multi : 'a list t -> map -> 'a list
              val change : 'a t -> map -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> map -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> map -> 'a option
              val find_exn : 'a t -> map -> 'a
              val remove : 'a t -> map -> 'a t
              val mem : 'a t -> map -> bool
              val iter_keys : 'a t -> f:(map -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:map -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:map ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:map -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:map ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(map -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:map -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:map -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:map -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:map -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> map list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (map * 'a) list
              val validate :
                name:(map -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:map ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (map, 'a) Base__.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (map * 'a) option
              val min_elt_exn : 'a t -> map * 'a
              val max_elt : 'a t -> (map * 'a) option
              val max_elt_exn : 'a t -> map * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:map -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:map -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:map -> data:'-> bool) -> int
              val split : 'a t -> map -> 'a t * (map * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:map Base__.Maybe_bound.t ->
                upper_bound:map Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:map ->
                max:map ->
                init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:map -> max:map -> (map * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> map -> (map * 'a) option
              val nth : 'a t -> int -> (map * 'a) option
              val nth_exn : 'a t -> int -> map * 'a
              val rank : 'a t -> map -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:map ->
                ?keys_less_or_equal_to:map ->
                'a t -> (map * 'a) Base__.Sequence.t
              val obs :
                map Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                map Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> map
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : map Bin_prot.Type_class.t
                           val bin_read_t : map Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> map)
                             Bin_prot.Read.reader
                           val bin_reader_t : map Bin_prot.Type_class.reader
                           val bin_size_t : map Bin_prot.Size.sizer
                           val bin_write_t : map Bin_prot.Write.writer
                           val bin_writer_t : map Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> map -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = map
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (map, comparator_witness) Core_kernel__.Set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  type named =
                      (map, comparator_witness)
                      Core_kernel__.Set_intf.Tree.Named.t
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(map -> unit) -> unit
                  val fold :
                    t -> init:'accum -> f:('accum -> map -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> map -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(map -> bool) -> bool
                  val for_all : t -> f:(map -> bool) -> bool
                  val count : t -> f:(map -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(map -> 'sum) -> 'sum
                  val find : t -> f:(map -> bool) -> map option
                  val find_map : t -> f:(map -> 'a option) -> 'a option
                  val to_list : t -> map list
                  val to_array : t -> map array
                  val invariants : t -> bool
                  val mem : t -> map -> bool
                  val add : t -> map -> t
                  val remove : t -> map -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (map, map) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  module Named :
                    sig
                      val is_subset :
                        named -> of_:named -> unit Base__.Or_error.t
                      val equal : named -> named -> unit Base__.Or_error.t
                    end
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       map -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                    finish:('-> 'final) -> 'final
                  val fold_right : t -> init:'-> f:(map -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of map * map | `Left of map | `Right of map ] ->
                       unit) ->
                    unit
                  val filter : t -> f:(map -> bool) -> t
                  val partition_tf : t -> f:(map -> bool) -> t * t
                  val elements : t -> map list
                  val min_elt : t -> map option
                  val min_elt_exn : t -> map
                  val max_elt : t -> map option
                  val max_elt_exn : t -> map
                  val choose : t -> map option
                  val choose_exn : t -> map
                  val split : t -> map -> t * map option * t
                  val group_by : t -> equiv:(map -> map -> bool) -> t list
                  val find_exn : t -> f:(map -> bool) -> map
                  val find_index : t -> int -> map option
                  val nth : t -> int -> map option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:map ->
                    ?less_or_equal_to:map -> t -> map Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:map ->
                    ?less_or_equal_to:map ->
                    t ->
                    t ->
                    (map, map) Base__.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(map -> 'data) ->
                    (map, 'data, comparator_witness) Core_kernel__.Map.t
                  val obs :
                    map Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    map Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : map -> t
                  val union_list : t list -> t
                  val of_list : map list -> t
                  val of_array : map array -> t
                  val of_sorted_array : map array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : map array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> map) -> t
                  val stable_dedup_list : map list -> map list
                  val map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> map) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                    f:('-> map option) -> t
                  val of_tree : t -> t
                  val of_hash_set : map Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys : (map, 'a) Label.Table.hashtbl -> t
                  val of_map_keys :
                    (map, 'a, comparator_witness) Core_kernel__.Map.t -> t
                  val gen :
                    map Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> map
                             end->
                      sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                  val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                end
              type t = (map, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              type named =
                  (map, comparator_witness) Core_kernel__.Set_intf.Named.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(map -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> map -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> map -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(map -> bool) -> bool
              val for_all : t -> f:(map -> bool) -> bool
              val count : t -> f:(map -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(map -> 'sum) -> 'sum
              val find : t -> f:(map -> bool) -> map option
              val find_map : t -> f:(map -> 'a option) -> 'a option
              val to_list : t -> map list
              val to_array : t -> map array
              val invariants : t -> bool
              val mem : t -> map -> bool
              val add : t -> map -> t
              val remove : t -> map -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (map, map) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              module Named :
                sig
                  val is_subset :
                    named -> of_:named -> unit Base__.Or_error.t
                  val equal : named -> named -> unit Base__.Or_error.t
                end
              val fold_until :
                t ->
                init:'->
                f:('->
                   map -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                finish:('-> 'final) -> 'final
              val fold_right : t -> init:'-> f:(map -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of map * map | `Left of map | `Right of map ] ->
                   unit) ->
                unit
              val filter : t -> f:(map -> bool) -> t
              val partition_tf : t -> f:(map -> bool) -> t * t
              val elements : t -> map list
              val min_elt : t -> map option
              val min_elt_exn : t -> map
              val max_elt : t -> map option
              val max_elt_exn : t -> map
              val choose : t -> map option
              val choose_exn : t -> map
              val split : t -> map -> t * map option * t
              val group_by : t -> equiv:(map -> map -> bool) -> t list
              val find_exn : t -> f:(map -> bool) -> map
              val find_index : t -> int -> map option
              val nth : t -> int -> map option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:map ->
                ?less_or_equal_to:map -> t -> map Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:map ->
                ?less_or_equal_to:map ->
                t ->
                t ->
                (map, map) Base__.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(map -> 'data) ->
                (map, 'data, comparator_witness) Core_kernel__.Map.t
              val obs :
                map Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                map Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : map -> t
              val union_list : t list -> t
              val of_list : map list -> t
              val of_array : map array -> t
              val of_sorted_array : map array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : map array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> map) -> t
              val stable_dedup_list : map list -> map list
              val map : ('a, 'b) Base.Set.t -> f:('-> map) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> map option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : map Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys : (map, 'a) Label.Table.hashtbl -> t
              val of_map_keys :
                (map, 'a, comparator_witness) Core_kernel__.Map.t -> t
              val gen :
                map Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> map
                         end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : map Bin_prot.Type_class.t
                           val bin_read_t : map Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> map)
                             Bin_prot.Read.reader
                           val bin_reader_t : map Bin_prot.Type_class.reader
                           val bin_size_t : map Bin_prot.Size.sizer
                           val bin_write_t : map Bin_prot.Write.writer
                           val bin_writer_t : map Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> map -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash_fold_t :
            Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
          val hashable : t Core_kernel__.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Label.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'b t -> Ppx_sexp_conv_lib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val findi_and_call :
                'b t ->
                key ->
                if_found:(key:key -> data:'-> 'c) ->
                if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val find_multi : 'b list t -> key -> 'b list
              module Provide_of_sexp :
                functor
                  (Key : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                         end->
                  sig
                    val t_of_sexp :
                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                      Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_first_class_module
              module Provide_of_sexp :
                functor
                  (X : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                       end->
                  sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = map
                  val compare : t -> t -> int
                  val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                'a t -> Ppx_sexp_conv_lib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
                finish:('accum -> 'final) -> 'final
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val max_elt : 'a t -> compare:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> map -> Core_kernel__.Import.bool
              val lookup : 'a t -> map -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> map -> 'a
              val enqueue :
                'a t -> map -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> map -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> map -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> map -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (map * 'a) Core_kernel__.Import.option
              val keys : 'a t -> map Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (map * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> map * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> map -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> map -> Core_kernel__.Import.unit
              val replace : 'a t -> map -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> map -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:map -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:map -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
    end
  type 'a source = 'Bap.Std.Source.t
  module Symbolizer :
    sig
      type t = Bap.Std.symbolizer
      val create : (Bap.Std.addr -> string option) -> Bap.Std.Symbolizer.t
      val of_blocks :
        (string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
        Bap.Std.Symbolizer.t
      val resolve : Bap.Std.Symbolizer.t -> Bap.Std.addr -> string
      val chain : Bap.Std.Symbolizer.t list -> Bap.Std.Symbolizer.t
      val empty : Bap.Std.Symbolizer.t
      module Factory :
        sig
          type t = Bap.Std.symbolizer
          val list : unit -> Trie.String.Suffix.key list
          val find : Trie.String.Suffix.key -> t Source.source option
          val register : Trie.String.Suffix.key -> t Source.source -> unit
        end
    end
  module Rooter :
    sig
      type t = Bap.Std.rooter
      val create : Bap.Std.addr Bap.Std.seq -> Bap.Std.Rooter.t
      val of_image : Bap.Std.image -> Bap.Std.Rooter.t
      val of_blocks :
        (string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
        Bap.Std.Rooter.t
      val roots : Bap.Std.Rooter.t -> Bap.Std.addr Bap.Std.seq
      val union : Bap.Std.Rooter.t -> Bap.Std.Rooter.t -> Bap.Std.Rooter.t
      module Factory :
        sig
          type t = Bap.Std.rooter
          val list : unit -> Trie.String.Suffix.key list
          val find : Trie.String.Suffix.key -> t Source.source option
          val register : Trie.String.Suffix.key -> t Source.source -> unit
        end
    end
  module Brancher :
    sig
      type t = Bap.Std.brancher
      type dest = Bap.Std.addr option * Bap.Std.edge
      val dest_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> dest
      val sexp_of_dest : dest -> Ppx_sexp_conv_lib.Sexp.t
      type dests = Bap.Std.Brancher.dest list
      val dests_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> dests
      val sexp_of_dests : dests -> Ppx_sexp_conv_lib.Sexp.t
      val create :
        (Bap.Std.mem ->
         Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Brancher.dests) ->
        Bap.Std.Brancher.t
      val of_bil : Bap.Std.arch -> Bap.Std.Brancher.t
      val resolve :
        Bap.Std.Brancher.t ->
        Bap.Std.mem ->
        Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Brancher.dests
      module Factory :
        sig
          type t = Bap.Std.brancher
          val list : unit -> Trie.String.Suffix.key list
          val find : Trie.String.Suffix.key -> t Source.source option
          val register : Trie.String.Suffix.key -> t Source.source -> unit
        end
    end
  module Reconstructor :
    sig
      type t = Bap.Std.reconstructor
      val create : (Bap.Std.cfg -> Bap.Std.symtab) -> Bap.Std.Reconstructor.t
      val default :
        (Bap.Std.word -> string) ->
        Bap.Std.word list -> Bap.Std.Reconstructor.t
      val of_blocks :
        (string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
        Bap.Std.Reconstructor.t
      val run : Bap.Std.Reconstructor.t -> Bap.Std.cfg -> Bap.Std.symtab
      module Factory :
        sig
          type t = Bap.Std.reconstructor
          val list : unit -> Trie.String.Suffix.key list
          val find : Trie.String.Suffix.key -> t Source.source option
          val register : Trie.String.Suffix.key -> t Source.source -> unit
        end
    end
  module Event :
    sig
      type t = ..
      type event = Bap.Std.Event.t = ..
      val stream : Bap.Std.Event.t Bap_future.Std.stream
      val send : Bap.Std.Event.t -> unit
      val register_printer : (Bap.Std.Event.t -> string option) -> unit
      module Log :
        sig
          type level = Debug | Info | Warning | Error
          type info = {
            level : Bap.Std.Event.Log.level;
            section : string;
            message : string;
          }
          type event += Message of Bap.Std.Event.Log.info
          val message :
            Bap.Std.Event.Log.level ->
            section:string ->
            ('a, Format.formatter, unit) Core_kernel.format -> 'a
          type event +=
              Progress of { task : string; note : string option;
                stage : int option; total : int option;
              }
          val progress :
            ?note:string -> ?stage:int -> ?total:int -> string -> unit
        end
      val to_string : t -> Trie.String.Suffix.key
      val str : unit -> t -> Trie.String.Suffix.key
      val pps : unit -> t -> Trie.String.Suffix.key
      val ppo : Core_kernel.Out_channel.t -> t -> unit
      val pp_seq : Format.formatter -> t Seq.t -> unit
      val pp : Base__.Formatter.t -> t -> unit
    end
  type event = Bap.Std.Event.t = ..
  type project
  module Project :
    sig
      type t = Bap.Std.project
      type input
      type info =
          Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
          Trie.String.Suffix.key option
      val version : Trie.String.Suffix.key
      val size_in_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> int
      val of_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
      val to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
      val blit_to_bytes :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t -> int -> unit
      val of_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> Core_kernel.bigstring -> t
      val to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.bigstring
      val blit_to_bigstring :
        ?ver:Trie.String.Suffix.key ->
        ?fmt:Trie.String.Suffix.key ->
        Core_kernel.bigstring -> t -> int -> unit
      module Io :
        sig
          val read :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
          val load :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.In_channel.t -> t
          val load_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            ?rev:bool -> Core_kernel.In_channel.t -> t list
          val scan :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.In_channel.t -> unit -> t option
          val write :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t -> unit
          val save :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t -> unit
          val save_all :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> t list -> unit
          val dump :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Out_channel.t -> (unit -> t option) -> unit
          val show :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> unit
          val print :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
        end
      module Cache :
        sig
          val load : Regular.Std.digest -> t option
          val save : Regular.Std.digest -> t -> unit
        end
      val add_reader :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader -> unit
      val add_writer :
        ?desc:Trie.String.Suffix.key ->
        ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer -> unit
      val available_readers : unit -> info list
      val default_reader : unit -> info
      val set_default_reader :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val available_writers : unit -> info list
      val default_writer : unit -> info
      val set_default_writer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val default_printer : unit -> info option
      val set_default_printer :
        ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
      val with_printer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> (unit -> 'a) -> 'a
      val find_reader :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.reader option
      val find_writer :
        ?ver:Trie.String.Suffix.key ->
        Trie.String.Suffix.key -> t Regular.Std.writer option
      val create :
        ?disassembler:string ->
        ?brancher:Bap.Std.brancher Bap.Std.source ->
        ?symbolizer:Bap.Std.symbolizer Bap.Std.source ->
        ?rooter:Bap.Std.rooter Bap.Std.source ->
        ?reconstructor:Bap.Std.reconstructor Bap.Std.source ->
        Bap.Std.Project.input -> Bap.Std.Project.t Core_kernel.Or_error.t
      val arch : Bap.Std.Project.t -> Bap.Std.arch
      val disasm : Bap.Std.Project.t -> Bap.Std.disasm
      val program : Bap.Std.Project.t -> Bap.Std.program Bap.Std.term
      val with_program :
        Bap.Std.Project.t ->
        Bap.Std.program Bap.Std.term -> Bap.Std.Project.t
      val symbols : Bap.Std.Project.t -> Bap.Std.symtab
      val with_symbols :
        Bap.Std.Project.t -> Bap.Std.symtab -> Bap.Std.Project.t
      val storage : Bap.Std.Project.t -> Bap.Std.dict
      val with_storage :
        Bap.Std.Project.t -> Bap.Std.dict -> Bap.Std.Project.t
      val memory : Bap.Std.Project.t -> Bap.Std.value Bap.Std.memmap
      val tag_memory :
        Bap.Std.Project.t ->
        Bap.Std.mem -> 'Bap.Std.tag -> '-> Bap.Std.Project.t
      val substitute :
        Bap.Std.Project.t ->
        Bap.Std.mem -> string Bap.Std.tag -> string -> Bap.Std.Project.t
      val with_memory :
        Bap.Std.Project.t ->
        Bap.Std.value Bap.Std.memmap -> Bap.Std.Project.t
      val set :
        Bap.Std.Project.t -> 'Bap.Std.tag -> '-> Bap.Std.Project.t
      val get : Bap.Std.Project.t -> 'Bap.Std.tag -> 'a option
      val has : Bap.Std.Project.t -> 'Bap.Std.tag -> bool
      val del : Bap.Std.Project.t -> 'Bap.Std.tag -> Bap.Std.Project.t
      module Info :
        sig
          val file : string Bap_future.Std.stream
          val arch : Bap.Std.arch Bap_future.Std.stream
          val data : Bap.Std.value Bap.Std.memmap Bap_future.Std.stream
          val code : Bap.Std.value Bap.Std.memmap Bap_future.Std.stream
          val cfg : Bap.Std.cfg Bap_future.Std.stream
          val symtab : Bap.Std.symtab Bap_future.Std.stream
          val program : Bap.Std.program Bap.Std.term Bap_future.Std.stream
          val spec : Ogre.Doc.t Bap_future.Std.stream
        end
      module Input :
        sig
          type t = Bap.Std.Project.input
          val file :
            ?loader:string -> filename:string -> Bap.Std.Project.Input.t
          val binary :
            ?base:Bap.Std.addr ->
            Bap.Std.arch -> filename:string -> Bap.Std.Project.Input.t
          val create :
            ?finish:(Bap.Std.project -> Bap.Std.project) ->
            Bap.Std.arch ->
            string ->
            code:Bap.Std.value Bap.Std.memmap ->
            data:Bap.Std.value Bap.Std.memmap -> Bap.Std.Project.Input.t
          val register_loader :
            string -> (string -> Bap.Std.Project.Input.t) -> unit
          val available_loaders : unit -> string list
        end
      type pass
      val register_pass :
        ?autorun:bool ->
        ?runonce:bool ->
        ?deps:string list ->
        ?name:string -> (Bap.Std.Project.t -> Bap.Std.Project.t) -> unit
      val register_pass' :
        ?autorun:bool ->
        ?runonce:bool ->
        ?deps:string list ->
        ?name:string -> (Bap.Std.Project.t -> unit) -> unit
      val passes : unit -> Bap.Std.Project.pass list
      val find_pass : string -> Bap.Std.Project.pass option
      type second = float
      module Pass :
        sig
          type t = Bap.Std.Project.pass
          type error =
              Unsat_dep of Bap.Std.Project.pass * string
            | Runtime_error of Bap.Std.Project.pass * exn
          val sexp_of_error : error -> Ppx_sexp_conv_lib.Sexp.t
          exception Failed of Bap.Std.Project.Pass.error
          val run :
            Bap.Std.Project.Pass.t ->
            Bap.Std.project ->
            (Bap.Std.project, Bap.Std.Project.Pass.error)
            Core_kernel.Result.t
          val run_exn :
            Bap.Std.Project.Pass.t -> Bap.Std.project -> Bap.Std.project
          val name : Bap.Std.Project.Pass.t -> string
          val autorun : Bap.Std.Project.Pass.t -> bool
        end
      val restore_state : Bap.Std.Project.t -> unit
    end
  module Self :
    functor () ->
      sig
        val name : string
        val version : string
        val doc : string
        val argv : string array
        val debug : ('a, Format.formatter, unit) Core_kernel.format -> 'a
        val info : ('a, Format.formatter, unit) Core_kernel.format -> 'a
        val warning : ('a, Format.formatter, unit) Core_kernel.format -> 'a
        val error : ('a, Format.formatter, unit) Core_kernel.format -> 'a
        val debug_formatter : Format.formatter
        val info_formatter : Format.formatter
        val warning_formatter : Format.formatter
        val error_formatter : Format.formatter
        val report_progress :
          ?task:string ->
          ?note:string -> ?stage:int -> ?total:int -> unit -> unit
        module Config :
          sig
            val version : string
            val datadir : string
            val libdir : string
            val confdir : string
            type 'a param
            type 'parser = string -> [ `Error of string | `Ok of 'a ]
            type 'a converter
            val converter :
              'Bap.Std.Self.Config.parser ->
              'Regular.Std.printer ->
              '-> 'Bap.Std.Self.Config.converter
            val deprecated : string
            val param :
              'Bap.Std.Self.Config.converter ->
              ?deprecated:string ->
              ?default:'->
              ?as_flag:'->
              ?docv:string ->
              ?doc:string ->
              ?synonyms:string list -> string -> 'Bap.Std.Self.Config.param
            val param_all :
              'Bap.Std.Self.Config.converter ->
              ?deprecated:string ->
              ?default:'a list ->
              ?as_flag:'->
              ?docv:string ->
              ?doc:string ->
              ?synonyms:string list ->
              string -> 'a list Bap.Std.Self.Config.param
            val flag :
              ?deprecated:string ->
              ?docv:string ->
              ?doc:string ->
              ?synonyms:string list ->
              string -> bool Bap.Std.Self.Config.param
            val determined :
              'Bap.Std.Self.Config.param -> 'Bap_future.Std.future
            type reader = { get : 'a. 'Bap.Std.Self.Config.param -> 'a; }
            val when_ready : (Bap.Std.Self.Config.reader -> unit) -> unit
            type manpage_block =
                [ `I of string * string
                | `Noblank
                | `P of string
                | `Pre of string
                | `S of string ]
            val manpage : Bap.Std.Self.Config.manpage_block list -> unit
            val bool : bool Bap.Std.Self.Config.converter
            val char : char Bap.Std.Self.Config.converter
            val int : int Bap.Std.Self.Config.converter
            val nativeint : nativeint Bap.Std.Self.Config.converter
            val int32 : int32 Bap.Std.Self.Config.converter
            val int64 : int64 Bap.Std.Self.Config.converter
            val float : float Bap.Std.Self.Config.converter
            val string : string Bap.Std.Self.Config.converter
            val enum : (string * 'a) list -> 'Bap.Std.Self.Config.converter
            val doc_enum : ?quoted:bool -> (string * 'a) list -> string
            val file : string Bap.Std.Self.Config.converter
            val dir : string Bap.Std.Self.Config.converter
            val non_dir_file : string Bap.Std.Self.Config.converter
            val list :
              ?sep:char ->
              'Bap.Std.Self.Config.converter ->
              'a list Bap.Std.Self.Config.converter
            val array :
              ?sep:char ->
              'Bap.Std.Self.Config.converter ->
              'a array Bap.Std.Self.Config.converter
            val pair :
              ?sep:char ->
              'Bap.Std.Self.Config.converter ->
              'Bap.Std.Self.Config.converter ->
              ('a * 'b) Bap.Std.Self.Config.converter
            val t2 :
              ?sep:char ->
              'Bap.Std.Self.Config.converter ->
              'Bap.Std.Self.Config.converter ->
              ('a * 'b) Bap.Std.Self.Config.converter
            val t3 :
              ?sep:char ->
              'Bap.Std.Self.Config.converter ->
              'Bap.Std.Self.Config.converter ->
              'Bap.Std.Self.Config.converter ->
              ('a * 'b * 'c) Bap.Std.Self.Config.converter
            val t4 :
              ?sep:char ->
              'Bap.Std.Self.Config.converter ->
              'Bap.Std.Self.Config.converter ->
              'Bap.Std.Self.Config.converter ->
              'Bap.Std.Self.Config.converter ->
              ('a * 'b * 'c * 'd) Bap.Std.Self.Config.converter
            val some :
              ?none:string ->
              'Bap.Std.Self.Config.converter ->
              'a option Bap.Std.Self.Config.converter
          end
      end
  module Log : sig val start : ?logdir:string -> unit -> unit end
  module Monad :
    sig
      module type Basic = Core_kernel.Monad.Basic
      module type Basic2 = Core_kernel.Monad.Basic2
      module type Infix = Core_kernel.Monad.Infix
      module type Infix2 = Core_kernel.Monad.Infix2
      module type S = Core_kernel.Monad.S
      module type S2 = Core_kernel.Monad.S2
      module Make :
        functor (M : Basic->
          sig
            val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
            val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
            module Monad_infix :
              sig
                val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
              end
            val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
            val return : '-> 'M.t
            val map : 'M.t -> f:('-> 'b) -> 'M.t
            val join : 'M.t M.t -> 'M.t
            val ignore_m : 'M.t -> unit M.t
            val all : 'M.t list -> 'a list M.t
            val all_unit : unit M.t list -> unit M.t
            val all_ignore : unit M.t list -> unit M.t
            module Let_syntax :
              sig
                val return : '-> 'M.t
                val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                module Let_syntax :
                  sig
                    val return : '-> 'M.t
                    val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                    val map : 'M.t -> f:('-> 'b) -> 'M.t
                    val both : 'M.t -> 'M.t -> ('a * 'b) M.t
                    module Open_on_rhs : sig  end
                  end
              end
          end
      module Make2 :
        functor (M : Basic2->
          sig
            val ( >>= ) :
              ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) M.t
                val ( >>= ) :
                  ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) M.t
                    val bind :
                      ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                    val both :
                      ('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
              end
            val bind : ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val return : '-> ('a, 'b) M.t
            val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
            val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
            val ignore_m : ('a, 'e) M.t -> (unit, 'e) M.t
            val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
            val all_unit : (unit, 'e) M.t list -> (unit, 'e) M.t
            val all_ignore : (unit, 'e) M.t list -> (unit, 'e) M.t
          end
      module State :
        sig
          module type S =
            sig
              type ('a, 's) t
              type 'a result
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (unit, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit : (unit, 'e) t list -> (unit, 'e) t
              val all_ignore : (unit, 'e) t list -> (unit, 'e) t
              val put : '-> (unit, 's) t
              val get : unit -> ('s, 's) t
              val gets : ('-> 'r) -> ('r, 's) t
              val update : ('-> 's) -> (unit, 's) t
              val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
              val run : ('a, 's) t -> '-> ('a * 's) result
              val eval : ('a, 's) t -> '-> 'a result
              val exec : ('a, 's) t -> '-> 's result
            end
          type ('a, 'e) t = ('a, 'e) Taint.state
          type 'a result = 'a
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_unit : (unit, 'e) t list -> (unit, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          val put : '-> (unit, 's) t
          val get : unit -> ('s, 's) t
          val gets : ('-> 'r) -> ('r, 's) t
          val update : ('-> 's) -> (unit, 's) t
          val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
          val run : ('a, 's) t -> '-> 'a * 's
          val eval : ('a, 's) t -> '-> 'a
          val exec : ('a, 's) t -> '-> 's
        end
      module T :
        sig
          module Option :
            sig
              module Make :
                functor (M : S->
                  sig
                    type 'a t = 'a option M.t
                    val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                    val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    module Monad_infix :
                      sig
                        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      end
                    val bind : 'a t -> f:('-> 'b t) -> 'b t
                    val return : '-> 'a t
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val join : 'a t t -> 'a t
                    val ignore_m : 'a t -> unit t
                    val all : 'a t list -> 'a list t
                    val all_unit : unit t list -> unit t
                    val all_ignore : unit t list -> unit t
                    module Let_syntax :
                      sig
                        val return : '-> 'a t
                        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                        module Let_syntax :
                          sig
                            val return : '-> 'a t
                            val bind : 'a t -> f:('-> 'b t) -> 'b t
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val both : 'a t -> 'b t -> ('a * 'b) t
                            module Open_on_rhs : sig  end
                          end
                      end
                  end
              module Make2 :
                functor (M : S2->
                  sig
                    type ('a, 'b) t = ('a option, 'b) M.t
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val bind :
                              ('a, 'e) t ->
                              f:('-> ('b, 'e) t) -> ('b, 'e) t
                            val map :
                              ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                            val both :
                              ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      end
                    val bind :
                      ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                    val return : '-> ('a, 'b) t
                    val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                    val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                    val ignore_m : ('a, 'e) t -> (unit, 'e) t
                    val all : ('a, 'e) t list -> ('a list, 'e) t
                    val all_unit : (unit, 'e) t list -> (unit, 'e) t
                    val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                  end
            end
          module Or_error :
            sig
              module Make :
                functor (M : S->
                  sig
                    type 'a t = 'Memory.With_error.m M.t
                    val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                    val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    module Monad_infix :
                      sig
                        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      end
                    val bind : 'a t -> f:('-> 'b t) -> 'b t
                    val return : '-> 'a t
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val join : 'a t t -> 'a t
                    val ignore_m : 'a t -> unit t
                    val all : 'a t list -> 'a list t
                    val all_unit : unit t list -> unit t
                    val all_ignore : unit t list -> unit t
                    module Let_syntax :
                      sig
                        val return : '-> 'a t
                        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                        module Let_syntax :
                          sig
                            val return : '-> 'a t
                            val bind : 'a t -> f:('-> 'b t) -> 'b t
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val both : 'a t -> 'b t -> ('a * 'b) t
                            module Open_on_rhs : sig  end
                          end
                      end
                  end
              module Make2 :
                functor (M : S2->
                  sig
                    type ('a, 'b) t = ('Memory.With_error.m, 'b) M.t
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val bind :
                              ('a, 'e) t ->
                              f:('-> ('b, 'e) t) -> ('b, 'e) t
                            val map :
                              ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                            val both :
                              ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      end
                    val bind :
                      ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                    val return : '-> ('a, 'b) t
                    val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                    val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                    val ignore_m : ('a, 'e) t -> (unit, 'e) t
                    val all : ('a, 'e) t list -> ('a list, 'e) t
                    val all_unit : (unit, 'e) t list -> (unit, 'e) t
                    val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                  end
            end
          module Result :
            sig
              module Make :
                functor (M : S->
                  sig
                    type ('a, 'e) t = ('a, 'e) Core_kernel.Result.t M.t
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val bind :
                              ('a, 'e) t ->
                              f:('-> ('b, 'e) t) -> ('b, 'e) t
                            val map :
                              ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                            val both :
                              ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      end
                    val bind :
                      ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                    val return : '-> ('a, 'b) t
                    val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                    val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                    val ignore_m : ('a, 'e) t -> (unit, 'e) t
                    val all : ('a, 'e) t list -> ('a list, 'e) t
                    val all_unit : (unit, 'e) t list -> (unit, 'e) t
                    val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                  end
            end
          module State :
            sig
              module Make :
                functor (M : S->
                  sig
                    type ('a, 's) t
                    type 'a result = 'M.t
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val bind :
                              ('a, 'e) t ->
                              f:('-> ('b, 'e) t) -> ('b, 'e) t
                            val map :
                              ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                            val both :
                              ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      end
                    val bind :
                      ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                    val return : '-> ('a, 'b) t
                    val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                    val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                    val ignore_m : ('a, 'e) t -> (unit, 'e) t
                    val all : ('a, 'e) t list -> ('a list, 'e) t
                    val all_unit : (unit, 'e) t list -> (unit, 'e) t
                    val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                    val put : '-> (unit, 's) t
                    val get : unit -> ('s, 's) t
                    val gets : ('-> 'r) -> ('r, 's) t
                    val update : ('-> 's) -> (unit, 's) t
                    val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
                    val run : ('a, 's) t -> '-> ('a * 's) result
                    val eval : ('a, 's) t -> '-> 'a result
                    val exec : ('a, 's) t -> '-> 's result
                  end
            end
        end
    end
end